import { Get, Has, KeysOfValues, Lookup, Values } from './common.js';
import { ContentFormat, MimeType, OperationDefinition, OperationType, OperationTypes, ResponseCode, ResponsesType } from './operations.js';
export type WithMimeTypeGlobs<M extends MimeType> = M | MimeTypePrefixes<M> | '*/*';
export declare const FALLBACK_MIME_TYPE = "*/*";
export declare const FORM_MIME_TYPE = "application/x-www-form-urlencoded";
export declare const JSON_MIME_TYPE = "application/json";
export declare const JSON_SEQ_MIME_TYPE = "application/json-seq";
export declare const OCTET_STREAM_MIME_TIME = "application/octet-stream";
export declare const MULTIPART_MIME_TYPE = "multipart/*";
export declare const MULTIPART_FORM_MIME_TYPE = "multipart/form-data";
export declare const PLAIN_MIME_TYPE = "text/plain";
export declare const TEXT_MIME_TYPE = "text/*";
export type MimeTypePrefixes<M extends MimeType> = M extends `${infer P}/${infer _S}` ? `${P}/*` : never;
export type SplitMimeTypes<G extends MimeType> = G extends `${infer G1}, ${infer G2}` ? ExtractMimeType<G1> | SplitMimeTypes<G2> : ExtractMimeType<G>;
type ExtractMimeType<G extends MimeType> = G extends `${infer M};${string}` ? M : G;
export type ValuesMatchingMimeTypes<O, G extends MimeType> = Values<{
    [M in keyof O & MimeType]: SplitMimeTypes<G> & WithMimeTypeGlobs<M> extends never ? never : O[M];
}>;
export declare function matchingContentType(exact: MimeType, accepted: Iterable<MimeType>): MimeType | undefined;
export declare class ByMimeType<V> {
    private readonly entries;
    private constructor();
    static create<V>(fallback: V): ByMimeType<V>;
    add(key: MimeType, val: V): void;
    addAll(items: Record<MimeType, V> | undefined): void;
    getBest(key: MimeType): V;
}
export type BodyContent<O extends OperationType> = Exclude<Lookup<O, 'requestBody'>, undefined>['content'];
export type BodyMimeTypes<O extends OperationType> = BodyContent<O> extends never ? never : keyof BodyContent<O> & MimeType;
export type AllBodyMimeTypes<O extends OperationTypes> = Values<{
    [K in keyof O]: BodyMimeTypes<O[K]>;
}>;
export type BodiesMatchingMimeType<O extends OperationTypes<keyof O & string>, G extends MimeType> = Values<{
    [K in keyof O]: ValuesMatchingMimeTypes<BodyContent<O[K]>, G>;
}>;
export type AllResponseMimeTypes<O extends OperationTypes<keyof O & string>> = Values<{
    [K in keyof O]: ResponseMimeTypes<O[K]['responses']>;
}> & MimeType;
export type ResponseMimeTypes<R extends ResponsesType, C extends keyof R = keyof R> = KeysOfValues<{
    [P in C]: Get<R[P], 'content'>;
}> & MimeType;
export type AllResponsesMatchingMimeType<O extends OperationTypes, G extends MimeType> = Values<{
    [K in keyof O]: ResponsesMatchingMimeType<O[K]['responses'], G>;
}>;
export type ResponsesMatchingMimeType<R extends ResponsesType, G extends MimeType> = Values<{
    [C in keyof R]: R[C] extends Has<'content', infer O> ? ValuesMatchingMimeTypes<O, G> : never;
}>;
export declare class ResponseClauseMatcher {
    private readonly data;
    private constructor();
    static create(responses: OperationDefinition['responses']): ResponseClauseMatcher;
    getBest(status: number): ResponseClause;
    private getBestCode;
    acceptable(accepted: Iterable<MimeType>): boolean;
}
/**
 * If returns true and `value` is not-null, it is guaranteed that `value` is a
 * key in `declared`.
 */
export declare function isResponseTypeValid(args: {
    readonly value: MimeType | undefined;
    readonly declared: ReadonlyMap<MimeType, ContentFormat> | undefined;
    readonly accepted: ReadonlySet<MimeType>;
}): boolean;
export declare function acceptedMimeTypes(header: string): ReadonlySet<MimeType>;
export interface ResponseClause {
    readonly code: ResponseCode;
    readonly declared?: ReadonlyMap<MimeType, ContentFormat>;
}
export {};