import { KeyedSegment } from '@sanity/types';
import { MultipleMutationResult } from '@sanity/client';
import { Mutation as Mutation_2 } from '@sanity/client';
import { Path } from '@sanity/types';
import { ReadableStream as ReadableStream_2 } from 'node:stream/web';
import { SanityClient } from '@sanity/client';
import { SanityDocument as SanityDocument_2 } from '@sanity/types';

/**
 * @public
 */
export declare const ALLOWED_PROPERTIES: readonly ["fetch", "clone", "config", "withConfig", "getDocument", "getDocuments", "users", "projects"];

/**
 * @public
 */
export declare type AllowedMethods = (typeof ALLOWED_PROPERTIES)[number];

/**
 * @public
 */
export declare type AnyArray<T = any> = readonly T[] | T[];

/**
 * @public
 *
 * Represents an operation that can be applied to values of all types
 */
export declare type AnyOp = SetIfMissingOp<unknown> | SetOp<unknown> | UnsetOp;

/**
 * API configuration for the migration runner
 * @public
 */
export declare interface APIConfig {
    apiVersion: 'vX' | `v${number}-${number}-${number}`;
    dataset: string;
    projectId: string;
    token: string;
    apiHost?: string;
}

/**
 * Creates an `insert` operation that appends the provided items.
 * @public
 * @param items - The items to append.
 * @returns An `insert` operation for adding a value to the end of an array.
 * {@link https://www.sanity.io/docs/http-patches#Cw4vhD88}
 *
 * @example
 * ```ts
 * const appendFoo = append('foo')
 * const appendObject = append({name: 'foo'})
 * const appendObjects = append([{name: 'foo'}, [{name: 'bar'}]])
 * ```
 */
export declare function append<const Items extends AnyArray<unknown>>(items: ArrayElement<Items> | Items): InsertOp<NormalizeReadOnlyArray<Items>, "after", -1>;

/**
 * @public
 */
export declare type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;

/**
 * @public
 *
 * Represents ann operation that can be applied to an array
 */
export declare type ArrayOp = InsertOp<AnyArray, RelativePosition, IndexedSegment | KeyedSegment> | ReplaceOp<AnyArray, IndexedSegment | KeyedSegment> | TruncateOp;

/**
 * @public
 */
export declare type AsyncIterableMigration = (documents: () => AsyncIterableIterator<SanityDocument_2>, context: MigrationContext) => AsyncGenerator<(Mutation | Transaction)[] | Mutation | Transaction>;

/**
 * Creates a {@link NodePatch} at a specific path.
 * @public
 * @param path - The path where the operation should be applied.
 * @param operation - The operation to be applied.
 * @returns The node patch.
 */
export declare function at<O extends Operation>(path: Path | string, operation: O): NodePatch<Path, O>;

/**
 * @public
 */
export declare function collectMigrationMutations(migration: Migration, documents: () => AsyncIterableIterator<SanityDocument_2>, context: MigrationContext): AsyncGenerator<Transaction | Mutation | (Transaction | Mutation)[], any, any>;

/**
 * Creates a new document.
 * @public
 * @param document - The document to be created.
 * @returns The mutation to create the document.
 */
export declare function create<Doc extends Optional<SanityDocument, '_id'>>(document: Doc): CreateMutation<Doc>;

/**
 * Creates a document if it does not exist.
 * @public
 * @param document - The document to be created.
 * @returns The mutation operation to create the document if it does not exist.
 */
export declare function createIfNotExists<Doc extends SanityDocument>(document: Doc): CreateIfNotExistsMutation<Doc>;

/**
 * @public
 *
 * Represents a mutation that can create a new document in the Sanity Content Lake if its ID does not exist.
 */
export declare type CreateIfNotExistsMutation<Doc extends SanityDocument> = {
    document: Doc;
    type: 'createIfNotExists';
};

/**
 * @public
 *
 * Represents a mutation that creates a new document in the Sanity Content Lake. This mutation will fail if the ID already exist.
 */
export declare type CreateMutation<Doc extends Optional<SanityDocument, '_id'>> = {
    document: Doc;
    type: 'create';
};

/**
 * Creates or replaces a document.
 * @public
 * @param document - The document to be created or replaced.
 * @returns The mutation operation to create or replace the document.
 */
export declare function createOrReplace<Doc extends SanityDocument>(document: Doc): CreateOrReplaceMutation<Doc>;

/**
 * @public
 *
 * Represents a mutation that can create or replace a document in the Sanity Content Lake given its ID.
 */
export declare type CreateOrReplaceMutation<Doc extends SanityDocument> = {
    document: Doc;
    type: 'createOrReplace';
};

/**
 * Creates a `dec` (decrement) operation with the provided amount.
 * @public
 * @param amount - The amount to decrement by.
 * @returns A `dec` operation.
 * {@link https://www.sanity.io/docs/http-patches#vIT8WWQo}
 *
 * @example
 * ```ts
 * const decBy1 = dec()
 * const decBy10 = dec(10)
 * ```
 */
export declare const dec: <const N extends number = 1>(amount?: N) => DecOp<N>;

/**
 * @public
 */
export declare function decodeText(it: AsyncIterableIterator<Uint8Array>): AsyncGenerator<string, void, unknown>;

/**
 * @public
 *
 * Represents a decrement-operation that can be applied to a number
 */
export declare type DecOp<Amount extends number> = {
    amount: Amount;
    type: 'dec';
};

/**
 * @public
 */
export declare const DEFAULT_MUTATION_CONCURRENCY = 6;

/**
 * @public
 *
 * Helper function for defining a Sanity content migration. This function does not do anything on its own;
 * it exists to check that your schema definition is correct, and help autocompletion in your IDE.
 *
 * {@link https://www.sanity.io/docs/schema-and-content-migrations#af2be129ccd6}

 * @example Basic usage
 *
 * ```ts
 * export default defineMigration({
 *  title: 'Make sure all strings with “acme” is uppercased to “ACME”',
 *  migrate: {
 *    string(node, path, context) {
 *      if (node === "acme") {
 *        return set(node.toUpperCase())
 *      }
 *    },
 *  },
 * })
 * ```
 * @param migration - The migration definition
 *
 * See {@link Migration}
 */
export declare function defineMigration<T extends Migration>(migration: T): T;

/**
 * Alias for delete
 * @public
 */
export declare const del: typeof delete_;

/**
 * @public
 */
export declare function delay<T>(it: AsyncIterableIterator<T>, ms: number): AsyncGenerator<Awaited<T>, void, unknown>;

/**
 * Deletes a document.
 * @public
 * @param id - The id of the document to be deleted.
 * @returns The mutation operation to delete the document.
 */
export declare function delete_(id: string): DeleteMutation;

/**
 * @public
 *
 * Represents a mutation that can delete a document in the Sanity Content Lake.
 */
export declare type DeleteMutation = {
    id: string;
    type: 'delete';
};

/**
 * Creates a `diffMatchPatch` operation with the provided value.
 * @param value - The value for the diff match patch operation.
 * @returns A `diffMatchPatch` operation.
 * {@link https://www.sanity.io/docs/http-patches#aTbJhlAJ}
 * @public
 */
export declare const diffMatchPatch: (value: string) => DiffMatchPatchOp;

/**
 * @public
 *
 * Represents a diff-match-patch operation that can be applied to a string
 * {@link https://www.npmjs.com/package/@sanity/diff-match-patch}
 */
export declare type DiffMatchPatchOp = {
    type: 'diffMatchPatch';
    value: string;
};

/**
 * @public
 *
 * Possible return values from a migration helper that runs on a document as a whole
 * Currently, this is only applies to {@link NodeMigration.document}
 */
export declare type DocumentMigrationReturnValue = Mutation | Mutation[] | NodePatch | NodePatch[] | Mutation_2 | Mutation_2[];

/**
 * @public
 */
export declare function dryRun(config: MigrationRunnerOptions, migration: Migration): AsyncGenerator<Transaction | Mutation | (Transaction | Mutation)[], void, any>;

/**
 * API configuration for exports
 * @public
 */
export declare interface ExportAPIConfig extends APIConfig {
    documentTypes?: string[];
}

/**
 * @public
 */
export declare interface FetchOptions {
    init: RequestInit;
    url: string | URL;
}

/**
 * @public
 */
export declare function filter<T>(it: AsyncIterableIterator<T>, predicate: (value: T) => boolean | Promise<boolean>): AsyncGenerator<Awaited<T>, void, unknown>;

/**
 * @public
 */
export declare function fromDocuments(documents: SanityDocument_2[]): Generator<SanityDocument_2, void, unknown>;

/**
 * @public
 */
export declare function fromExportArchive(path: string): AsyncGenerator<Uint8Array, void, unknown>;

/**
 * @public
 */
export declare function fromExportEndpoint(options: ExportAPIConfig): Promise<ReadableStream_2<any>>;

/**
 * Creates an `inc` (increment) operation with the provided amount.
 * @public
 * @param amount - The amount to increment by.
 * @returns An incrementation operation for numeric values
 * {@link https://www.sanity.io/docs/http-patches#vIT8WWQo}
 *
 * @example
 * ```ts
 * const incBy1 = inc()
 * const incBy5 = inc(5)
 * ```
 */
export declare const inc: <const N extends number = 1>(amount?: N) => IncOp<N>;

/**
 * @public
 *
 * Represents an increment-operation that can be applied to a number
 */
export declare type IncOp<Amount extends number> = {
    amount: Amount;
    type: 'inc';
};

/**
 * @public
 *
 * Represents an indexed segment in a document.
 */
export declare type IndexedSegment = number;

/**
 * Creates an `insert` operation with the provided items, position, and reference item.
 * @public
 * @param items - The items to insert.
 * @param position - The position to insert at.
 * @param indexOrReferenceItem - The index or reference item to insert before or after.
 * @returns An `insert` operation for adding values to arrays
 * {@link https://www.sanity.io/docs/http-patches#febxf6Fk}
 *
 * @example
 * ```ts
 * const prependFoo = insert(['foo'], 'before', 0)
 * const appendFooAndBar = insert(['foo', 'bar'], 'after', someArray.length -1)
 * const insertObjAfterXYZ = insert({name: 'foo'}, 'after', {_key: 'xyz'}])
 * ```
 */
export declare function insert<const Items extends AnyArray<unknown>, const Pos extends RelativePosition, const ReferenceItem extends IndexedSegment | KeyedSegment>(items: ArrayElement<Items> | Items, position: Pos, indexOrReferenceItem: ReferenceItem): InsertOp<NormalizeReadOnlyArray<Items>, Pos, ReferenceItem>;

/**
 * Creates an `insert` operation that inserts the provided items after the provided index or reference item.
 * @public
 * @param items - The items to insert.
 * @param indexOrReferenceItem - The index or reference item to insert after.
 * @returns An `insert` operation after the provided index or reference item.
 * {@link https://www.sanity.io/docs/http-patches#0SQmPlb6}
 *
 * @example
 * ```ts
 * const insertFooAfterIndex3 = insertAfter('foo', 3)
 * const insertObjectAfterKey = insertAfter({name: 'foo'}, {_key: 'xyz'}]
 * ```
 */
export declare const insertAfter: <const Items extends AnyArray<unknown>, const ReferenceItem extends IndexedSegment | KeyedSegment>(items: ArrayElement<Items> | Items, indexOrReferenceItem: ReferenceItem) => InsertOp<NormalizeReadOnlyArray<Items>, "after", ReferenceItem>;

/**
 * Creates an `insert` operation that inserts the provided items before the provided index or reference item.
 * @param items - The items to insert.
 * @param indexOrReferenceItem - The index or reference item to insert before.
 * @returns An `insert` operation before the provided index or reference item.
 * {@link https://www.sanity.io/docs/http-patches#0SQmPlb6}
 * @public
 *
 * @example
 * ```ts
 * const insertFooBeforeIndex3 = insertBefore('foo', 3)
 * const insertObjectBeforeKey = insertBefore({name: 'foo'}, {_key: 'xyz'}]
 * ```
 */
export declare function insertBefore<const Items extends AnyArray<unknown>, const ReferenceItem extends IndexedSegment | KeyedSegment>(items: ArrayElement<Items> | Items, indexOrReferenceItem: ReferenceItem): InsertOp<NormalizeReadOnlyArray<Items>, "before", ReferenceItem>;

/**
 * @public
 *
 * Represents an insert-operation that can be applied to an array
 */
export declare type InsertOp<Items extends AnyArray, Pos extends RelativePosition, ReferenceItem extends IndexedSegment | KeyedSegment> = {
    items: Items;
    position: Pos;
    referenceItem: ReferenceItem;
    type: 'insert';
};

/**
 * @public
 */
export declare type JsonArray = JsonValue[] | readonly JsonValue[];

/**
 * @public
 */
export declare type JsonObject = {
    [Key in string]: JsonValue;
} & {
    [Key in string]?: JsonValue | undefined;
};

/**
 * @public
 */
export declare interface JSONOptions<Type> {
    parse?: JSONParser<Type>;
}

/**
 * @public
 */
export declare type JSONParser<Type> = (line: string) => Type;

/**
 * @public
 */
export declare type JsonPrimitive = boolean | number | string | null;

/**
 * @public
 */
export declare type JsonValue = JsonArray | JsonObject | JsonPrimitive;

export { KeyedSegment }

/**
 * @public
 */
export declare function map<T, U>(it: AsyncIterableIterator<T>, project: (value: T) => U): AsyncIterableIterator<U>;

/**
 * @public
 */
export declare const MAX_MUTATION_CONCURRENCY = 10;

/**
 * @public
 *
 * Interface for `Migration['migrate']`. Either a NodeMigration or an AsyncIterableMigration
 * {@link NodeMigration}
 * {@link AsyncIterableMigration}
 */
export declare type MigrateDefinition = AsyncIterableMigration | NodeMigration;

/**
 * @public
 *
 * Main interface for a content migration definition
 * {@link https://www.sanity.io/docs/schema-and-content-migrations#af2be129ccd6}
 */
export declare interface Migration<Def extends MigrateDefinition = MigrateDefinition> {
    /**
     * An object of named helper functions corresponding to the primary schema type of the content you want to migrate.
     * You can also run these functions as async and return the migration instructions as promises if you need to fetch data from elsewhere.
     * If you want more control, `migrate` can also be an async iterable function that yields mutations or transactions.
     * {@link NodeMigration}
     * {@link AsyncIterableMigration}
     *
     */
    migrate: Def;
    /**
     * A reader-friendly description of what the content migration does
     */
    title: string;
    /**
     * An array of document types to run the content migration on. If you don’t define this, the migration type will target all document types.
     * Note: This reflects the document types your migration will be based on, not necessarily the documents you will modify.
     */
    documentTypes?: string[];
    /**
     * A simple GROQ-filter (doesn’t support joins) for documents you want to run the content migration on.
     * Note: instead of adding `_type == 'yourType'` to the filter, it's better to add its `_type` to `documentTypes`.
     * Note: `documentTypes` and `filter` are combined with AND. This means a document will only be included in the
     * migration if its `_type` matches any of the provided `documentTypes` AND it also matches the `filter` (if provided).
     */
    filter?: string;
}

/**
 * @public
 *
 * Migration context. This will be passed to both async iterable migrations and node migration helper functions
 */
export declare interface MigrationContext {
    client: RestrictedClient;
    dryRun: boolean;
    filtered: {
        getDocument<T extends SanityDocument_2>(id: string): Promise<T | undefined>;
        getDocuments<T extends SanityDocument_2>(ids: string[]): Promise<T[]>;
    };
}

/**
 * Migration progress
 * @public
 */
export declare type MigrationProgress = {
    completedTransactions: MultipleMutationResult[];
    currentTransactions: (Mutation | Transaction)[];
    documents: number;
    done?: boolean;
    mutations: number;
    pending: number;
    queuedBatches: number;
};

/**
 * @public
 */
export declare interface MigrationRunnerConfig {
    api: APIConfig;
    concurrency?: number;
    onProgress?: (event: MigrationProgress) => void;
}

/**
 * @public
 */
export declare interface MigrationRunnerOptions {
    api: APIConfig;
    exportPath?: string;
}

/**
 * @public
 *
 * Represents a mutation that can be applied to a document in the Sanity Content Lake.
 */
export declare type Mutation<Doc extends SanityDocument = any> = CreateIfNotExistsMutation<Doc> | CreateMutation<Doc> | CreateOrReplaceMutation<Doc> | DeleteMutation | PatchMutation;

/**
 * @public
 *
 * Node migration helper functions. As the migration is processing a document, it will visit each node in the document, depth-first, call the appropriate helper function for the node type and collect any mutations returned from it.
 */
export declare interface NodeMigration {
    /**
     * Helper function that will be called for each array in each document included in the migration
     * @param object - The object value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    array?: <Node extends JsonArray>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function that will be called for each boolean value in each document included in the migration
     * @param string - The string value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    boolean?: <Node extends boolean>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function for migrating a document as a whole
     * @param doc - The document currently being processed
     * @param context - The {@link MigrationContext} instance
     */
    document?: <Doc extends SanityDocument_2>(doc: Doc, context: MigrationContext) => DocumentMigrationReturnValue | Promise<DocumentMigrationReturnValue | Transaction> | Transaction | void;
    /**
     * Helper function that will be called for each node in each document included in the migration
     * @param node - The node currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    node?: <Node extends JsonValue>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function that will be called for each `null` value in each document included in the migration
     * @param string - The string value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    null?: <Node extends null>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function that will be called for each number in each document included in the migration
     * @param string - The string value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    number?: <Node extends number>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function that will be called for each object in each document included in the migration
     * @param object - The object value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    object?: <Node extends JsonObject>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
    /**
     * Helper function that will be called for each string in each document included in the migration
     * @param string - The string value currently being visited
     * @param path - The path to the node within the document. See `Path`
     * @param context - The {@link MigrationContext} instance
     */
    string?: <Node extends string>(node: Node, path: Path, context: MigrationContext) => NodeMigrationReturnValue | Promise<NodeMigrationReturnValue | void> | void;
}

/**
 * @public
 *
 * Possible return values from a migration helper that runs on nodes within a document
 */
export declare type NodeMigrationReturnValue = DocumentMigrationReturnValue | Operation | Operation[];

/**
 * @public
 *
 * A NodePatch represents a single operation that can be applied at a node at a specific path in a Sanity document.
 */
export declare type NodePatch<P extends Path = Path, O extends Operation = Operation> = {
    op: O;
    path: P;
};

/**
 * @public
 *
 * A list of {@link NodePatch} objects.
 */
export declare type NodePatchList = [NodePatch, ...NodePatch[]] | NodePatch[] | readonly [NodePatch, ...NodePatch[]] | readonly NodePatch[];

/**
 * @public
 */
export declare type NormalizeReadOnlyArray<T> = T extends readonly [infer NP, ...infer Rest] ? [NP, ...Rest] : T extends readonly (infer NP)[] ? NP[] : T;

/**
 * @public
 *
 * Represents an operation that can be applied to a number
 */
export declare type NumberOp = DecOp<number> | IncOp<number>;

/**
 * @public
 *
 * Represents an operation that can be applied to values of all types
 */
export declare type Operation = ArrayOp | PrimitiveOp;

/**
 * @public
 */
export declare type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

/**
 * @public
 */
export declare function parse<Type>(it: AsyncIterableIterator<string>, options?: JSONOptions<Type>): AsyncIterableIterator<Type>;

/**
 * @public
 */
export declare function parseJSON<Type>(it: AsyncIterableIterator<string>, { parse }?: JSONOptions<Type>): AsyncIterableIterator<Type>;

/**
 * Applies a patch to a document.
 * @public
 * @param id - The ID of the document to be patched.
 * @param patches - The patches to be applied.
 * @param options - Optional patch options.
 * @returns The mutation to patch the document.
 */
export declare function patch<P extends NodePatch | NodePatchList>(id: string, patches: P, options?: PatchOptions): PatchMutation<NormalizeReadOnlyArray<Tuplify<P>>>;

/**
 * @public
 *
 * Represents a patch mutation that can change a value for a document in the Sanity Content Lake.
 */
export declare type PatchMutation<Patches extends NodePatchList = NodePatchList> = {
    id: string;
    options?: PatchOptions;
    patches: Patches;
    type: 'patch';
};

/**
 * @public
 *
 * Options for a patch operation.
 */
export declare type PatchOptions = {
    /**
     * {@link https://www.sanity.io/docs/http-mutations#26600a871378}
     */
    ifRevision?: string;
};

export { Path }

/**
 * Creates an `insert` operation that prepends the provided items.
 * @public
 * @param items - The items to prepend.
 * @returns An `insert` operation for adding a value to the start of an array.
 * {@link https://www.sanity.io/docs/http-patches#refAUsf0}
 *
 * @example
 * ```ts
 * const prependFoo = prepend('foo')
 * const prependObject = prepend({name: 'foo'})
 * const prependObjects = prepend([{name: 'foo'}, [{name: 'bar'}]])
 * ```
 */
export declare function prepend<const Items extends AnyArray<unknown>>(items: ArrayElement<Items> | Items): InsertOp<NormalizeReadOnlyArray<Items>, "before", 0>;

/**
 * @public
 *
 * Represents an operation that can be applied to any primitive value
 */
export declare type PrimitiveOp = AnyOp | NumberOp | StringOp;

/**
 * @public
 *
 * Represents a relative position in a document.
 */
export declare type RelativePosition = 'after' | 'before';

/**
 * Creates a `replace` operation with the provided items and reference item.
 * @public
 * @param items - The items to replace.
 * @param referenceItem - The reference item to replace.
 * @returns A ReplaceOp operation.
 * @remarks This will be converted to an `insert`/`replace` patch when submitted to the API
 * {@link https://www.sanity.io/docs/http-patches#GnVSwcPa}
 *
 * @example
 * ```ts
 * const replaceItem3WithFoo = replace('foo', 3)
 * const replaceItem3WithFooAndBar = replace(['foo', 'bar'], 3)
 * const replaceObject = replace({name: 'bar'}, {_key: 'xyz'})
 * ```
 */
export declare function replace<Items extends unknown[], ReferenceItem extends IndexedSegment | KeyedSegment>(items: ArrayElement<Items> | Items, referenceItem: ReferenceItem): ReplaceOp<Items, ReferenceItem>;

/**
 * @public
 *
 * Represents a replace-operation that can be applied to an array
 */
export declare type ReplaceOp<Items extends AnyArray, ReferenceItem extends IndexedSegment | KeyedSegment> = {
    items: Items;
    referenceItem: ReferenceItem;
    type: 'replace';
};

/**
 * @public
 */
export declare type RestrictedClient = Pick<SanityClient, AllowedMethods>;

/**
 * @public
 */
export declare function run(config: MigrationRunnerConfig, migration: Migration): Promise<void>;

/**
 * Safe JSON parser that is able to handle lines interrupted by an error object.
 *
 * This may occur when streaming NDJSON from the Export HTTP API.
 *
 * @public
 * @see {@link https://github.com/sanity-io/sanity/pull/1787 | Initial pull request}
 */
export declare const safeJsonParser: (line: string) => SanityDocument_2;

/**
 * @public
 *
 * A Sanity Content Lake document
 */
export declare type SanityDocument = {
    _createdAt?: string;
    _id?: string;
    _rev?: string;
    _type: string;
    _updatedAt?: string;
};

/**
 * Creates a `set` operation with the provided value.
 * @public
 * @param value - The value to set.
 * @returns A `set` operation.
 * {@link https://www.sanity.io/docs/http-patches#6TPENSW3}
 *
 * @example
 * ```ts
 * const setFoo = set('foo')
 * const setEmptyArray = set([])
 * ```
 */
export declare const set: <const T>(value: T) => SetOp<T>;

/**
 * Creates a `setIfMissing` operation with the provided value.
 * @public
 * @param value - The value to set if missing.
 * @returns A `setIfMissing` operation.
 * {@link https://www.sanity.io/docs/http-patches#A80781bT}
 * @example
 * ```ts
 * const setFooIfMissing = setIfMissing('foo')
 * const setEmptyArrayIfMissing = setIfMissing([])
 * ```
 */
export declare const setIfMissing: <const T>(value: T) => SetIfMissingOp<T>;

/**
 * @public
 *
 * Represents a setIfMissing operation that can be applied to any value
 */
export declare type SetIfMissingOp<T> = {
    type: 'setIfMissing';
    value: T;
};

/**
 * @public
 *
 * Represents a set-operation that can be applied to any value
 */
export declare type SetOp<T> = {
    type: 'set';
    value: T;
};

/**
 * @public
 */
export declare function split(it: AsyncIterableIterator<string>, delimiter: string): AsyncIterableIterator<string>;

/**
 * @public
 */
export declare function stringify(iterable: AsyncIterableIterator<unknown>): AsyncGenerator<string, void, unknown>;

/**
 * @public
 */
export declare function stringifyJSON(it: AsyncIterableIterator<unknown>): AsyncGenerator<string, void, unknown>;

/**
 * @public
 *
 * Represents an operation that can be applied to a string
 */
export declare type StringOp = DiffMatchPatchOp;

/**
 * @public
 */
export declare function take<T>(it: AsyncIterableIterator<T>, count: number): AsyncGenerator<Awaited<T>, void, unknown>;

/**
 * @public
 */
export declare function toArray<T>(it: AsyncIterableIterator<T>): Promise<T[]>;

/**
 * @public
 */
export declare function toFetchOptionsIterable(apiConfig: APIConfig, mutations: AsyncIterableIterator<TransactionPayload>): AsyncGenerator<FetchOptions, void, unknown>;

/**
 * @public
 */
export declare interface Transaction {
    mutations: Mutation[];
    type: 'transaction';
    id?: string;
}

/**
 * @public
 *
 * Wraps a set of mutations in a transaction.
 * Note: use with caution. Transactions cannot be optimized and will be submitted one-by-one, which means they will make
 * your migration run slower and produce more API requests.
 * @param transactionId - The transaction ID. This is optional and should usually be omitted, as it will be auto-generated by the server if not provided.
 * @param mutations - The mutations to include in the transaction.
 *
 * {@link https://www.sanity.io/docs/http-mutations#afccc1b9ef78}
 */
export declare function transaction(transactionId: string, mutations: Mutation[]): Transaction;

/**
 * @public
 */
export declare function transaction(mutations: Mutation[]): Transaction;

/**
 * @public
 */
export declare interface TransactionPayload {
    mutations: Mutation_2[];
    transactionId?: string;
}

/**
 * Creates a `truncate` operation that will remove all items after `startIndex` until the end of the array or the provided `endIndex`.
 * @public
 * @param startIndex - The start index for the truncate operation.
 * @param endIndex - The end index for the truncate operation.
 * @returns A `truncate` operation.
 * @remarks - This will be converted to an `unset` patch when submitted to the API
 * {@link https://www.sanity.io/docs/http-patches#xRtBjp8o}
 *
 * @example
 * ```ts
 * const clearArray = truncate(0)
 * const removeItems = truncate(3, 5) // Removes items at index 3, 4, and 5
 * const truncate200 = truncate(200) // Removes all items after index 200
 * ```
 */
export declare function truncate(startIndex: number, endIndex?: number): TruncateOp;

/**
 * @public
 *
 * Represents a truncate-operation that can be applied to an array
 */
export declare type TruncateOp = {
    endIndex?: number;
    startIndex: number;
    type: 'truncate';
};

/**
 * @public
 */
export declare type Tuplify<T> = T extends readonly [infer NP, ...infer Rest] ? [NP, ...Rest] : T extends readonly (infer NP)[] ? NP[] : [T];

/**
 * Creates an `unset` operation.
 * @public
 * @returns An `unset` operation.
 * {@link https://www.sanity.io/docs/http-patches#xRtBjp8o}
 *
 * @example
 * ```ts
 * const unsetAnyValue = unset()
 * ```
 */
export declare const unset: () => UnsetOp;

/**
 * @public
 *
 * Represents an unset operation that can be applied to any value
 */
export declare type UnsetOp = {
    type: 'unset';
};

export { }