import { ServiceClientOptions } from '../types/aws';
import { Endpoint, TransferHandler } from '../types/core';
import { HttpRequest, HttpResponse } from '../types/http';
/**
 * Compose a service API handler that accepts input as defined shape and responds conforming to defined output shape.
 * A service API handler is composed with:
 * * A transfer handler
 * * A serializer function
 * * A deserializer function
 * * A default config object
 *
 * The returned service API handler, when called, will trigger the following workflow:
 * 1. When calling the service API handler function, the default config object is merged into the input config
 * object to assign the default values of some omitted configs, resulting to a resolved config object.
 * 2. The `endpointResolver` function from the default config object will be invoked with the resolved config object and
 * API input object resulting to an endpoint instance.
 * 3. The serializer function is invoked with API input object and the endpoint instance resulting to an HTTP request
 * instance.
 * 4. The HTTP request instance and the resolved config object is passed to the transfer handler function.
 * 5. The transfer handler function resolves to an HTTP response instance(can be either successful or failed status code).
 * 6. The deserializer function is invoked with the HTTP response instance resulting to the API output object, and
 * return to the caller.
 *
 *
 * @param transferHandler Async function for dispatching HTTP requests and returning HTTP response.
 * @param serializer  Async function for converting object in defined input shape into HTTP request targeting a given
 * 	endpoint.
 * @param deserializer Async function for converting HTTP response into output object in defined output shape, or error
 * 	shape.
 * @param defaultConfig  object containing default options to be consumed by transfer handler, serializer and
 *  deserializer.
 * @returns a async service API handler function that accepts a config object and input object in defined shape, returns
 * 	an output object in defined shape. It may also throw error instance in defined shape in deserializer. The config
 *  object type is composed with options type of transferHandler, endpointResolver function as well as endpointResolver
 *  function's input options type, region string. The config object property will be marked as optional if it's also
 * 	defined in defaultConfig.
 *
 * @internal
 */
export declare const composeServiceApi: <TransferHandlerOptions, Input, Output, DefaultConfig>(transferHandler: TransferHandler<HttpRequest, HttpResponse, TransferHandlerOptions>, serializer: (input: Input, endpoint: Endpoint) => Promise<HttpRequest> | HttpRequest, deserializer: (output: HttpResponse) => Promise<Output>, defaultConfig: Partial<DefaultConfig>) => (config: OptionalizeKey<TransferHandlerOptions & ServiceClientOptions & // Required configs(e.g. endpointResolver, region) to serialize input shapes into requests
InferEndpointResolverOptionType<DefaultConfig> & // Required inputs for endpointResolver
Partial<DefaultConfig>, // Properties defined in default configs, we need to allow overwriting them when invoking the service API handler
DefaultConfig>, input: Input) => Promise<Output>;
/**
 * Type helper to make a given key optional in a given type. For all the keys in the `InputDefaultsType`, if its value
 * is assignable to the value of the same key in `InputType`, we will mark the key in `InputType` is optional. If
 * the `InputType` and `InputDefaultsType` has the same key but un-assignable types, the resulting type is `never` to
 * trigger a type error down the line.
 *
 * @example
 * type InputType = {
 *   a: string;
 *   b: number;
 *   c: string;
 * };
 * type InputDefaultsType = {
 *   a: string;
 *   b: number;
 * };
 * type OutputType = OptionalizeKey<InputType, InputDefaultsType>;
 * OutputType equals to:
 * {
 *   a?: string;
 *   b?: number;
 *   c: string;
 * }
 */
type OptionalizeKey<InputType, InputDefaultsType> = {
    [KeyWithDefaultValue in keyof InputDefaultsType]?: KeyWithDefaultValue extends keyof InputType ? InputType[KeyWithDefaultValue] : never;
} & {
    [KeyWithoutDefaultValue in keyof Omit<InputType, keyof InputDefaultsType>]: InputType[KeyWithoutDefaultValue];
};
type InferEndpointResolverOptionType<T> = T extends {
    endpointResolver(options: infer EndpointOptions, input: any): any;
} ? EndpointOptions : never;
export {};