import type { temporal } from '@temporalio/proto';
import type { Payload } from '../interfaces';
import type { PayloadCodec } from '../converter/payload-codec';
import type { ProtoFailure } from '../failure';
import type { LoadedDataConverter } from '../converter/data-converter';
import type { UserMetadata } from '../user-metadata';
import type { TypeInfo } from '../type-info';
import type { SerializationContext } from '../converter/serialization-context';
import type { DecodedPayload, DecodedProtoFailure, EncodedPayload, EncodedProtoFailure } from './codec-types';
/**
 * Decode through each codec, starting with the last codec.
 */
export declare function decode(codecs: PayloadCodec[], payloads: Payload[], context?: SerializationContext): Promise<DecodedPayload[]>;
/**
 * Encode through each codec, starting with the first codec.
 */
export declare function encode(codecs: PayloadCodec[], payloads: Payload[], context?: SerializationContext): Promise<EncodedPayload[]>;
/** Run {@link PayloadCodec.decode} on a single Payload */
export declare function decodeOptionalSingle(codecs: PayloadCodec[], payload: Payload | null | undefined, context?: SerializationContext): Promise<DecodedPayload | null | undefined>;
/** Run {@link PayloadCodec.decode} and convert from a single Payload */
export declare function decodeOptionalSinglePayload<T>(dataConverter: LoadedDataConverter, payload?: Payload | null | undefined, context?: SerializationContext): Promise<T | null | undefined>;
/** Apply optional TypeInfo, run payload conversion, and then encode the resulting Payload. */
export declare function encodeToPayload<T>(converter: LoadedDataConverter, value: T, context?: SerializationContext, typeInfo?: TypeInfo<T, unknown>): Promise<Payload>;
/**
 * Decode `payloads` and then return {@link arrayFromPayloads}`.
 */
export declare function decodeArrayFromPayloads(converter: LoadedDataConverter, payloads?: Payload[] | null, context?: SerializationContext, typeInfo?: readonly TypeInfo[]): Promise<unknown[]>;
/**
 * Decode `payloads` and then return {@link fromPayloadsAtIndex}.
 */
export declare function decodeFromPayloadsAtIndex<T, D = T>(converter: LoadedDataConverter, index: number, payloads?: Payload[] | null, context?: SerializationContext, typeInfo?: TypeInfo<T, D>): Promise<T>;
/**
 * Run {@link decodeFailure} and then return {@link failureToError}.
 */
export declare function decodeOptionalFailureToOptionalError(converter: LoadedDataConverter, failure: ProtoFailure | undefined | null, context?: SerializationContext): Promise<Error | undefined>;
/**
 * Run {@link PayloadConverter.toPayload} on values, and then encode them.
 */
export declare function encodeToPayloads(converter: LoadedDataConverter, ...values: unknown[]): Promise<Payload[] | undefined>;
/**
 * Run {@link PayloadConverter.toPayload} on values with an optional serialization context, and then encode them.
 */
export declare function encodeToPayloadsWithContext(converter: LoadedDataConverter, context: SerializationContext | undefined, values: unknown[], typeInfo?: readonly TypeInfo[]): Promise<Payload[] | undefined>;
/**
 * Run {@link PayloadCodec.decode} and then {@link PayloadConverter.fromPayload} on values in `map`.
 */
export declare function decodeMapFromPayloads<K extends string>(converter: LoadedDataConverter, map: Record<K, Payload> | null | undefined, context?: SerializationContext): Promise<Record<K, unknown> | undefined>;
/**
 * Run {@link PayloadConverter.toPayload} and then {@link PayloadCodec.encode} on values in `map`.
 */
export declare function encodeMapToPayloads<K extends string>(converter: LoadedDataConverter, map: Record<K, unknown>, context?: SerializationContext): Promise<Record<K, Payload>>;
/**
 * Run {@link errorToFailure} on `error`, and then {@link encodeFailure}.
 */
export declare function encodeErrorToFailure(dataConverter: LoadedDataConverter, error: unknown, context?: SerializationContext): Promise<ProtoFailure>;
/**
 * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
 */
export declare function encodeFailure(codecs: PayloadCodec[], failure: ProtoFailure, context?: SerializationContext): Promise<EncodedProtoFailure>;
/**
 * Return a new {@link ProtoFailure} with `codec.decode()` run on all the {@link Payload}s.
 */
export declare function decodeFailure(codecs: PayloadCodec[], failure: ProtoFailure, context?: SerializationContext): Promise<DecodedProtoFailure>;
export declare function encodeUserMetadata(dataConverter: LoadedDataConverter, staticSummary: string | undefined, staticDetails: string | undefined, context?: SerializationContext): Promise<temporal.api.sdk.v1.IUserMetadata | undefined>;
export declare function decodeUserMetadata(dataConverter: LoadedDataConverter, metadata: temporal.api.sdk.v1.IUserMetadata | undefined | null, context?: SerializationContext): Promise<UserMetadata>;