declare const complexNested: () => (x: number) => (y: string) => (z: boolean) => {
    x: number;
    y: string;
    z: boolean;
};
declare const result: {
    increment: () => number;
    decrement: () => number;
    getValue: () => number;
};
declare function processConfig({ api, cache, retry, }?: {
    api?: {
        baseUrl: string;
        timeout: number;
    };
    cache?: {
        enabled: boolean;
        ttl: number;
    };
    retry?: {
        maxAttempts: number;
        backoff: string;
    };
}): {
    api: {
        baseUrl: string;
        timeout: number;
    };
    cache: {
        enabled: boolean;
        ttl: number;
    };
    retry: {
        maxAttempts: number;
        backoff: string;
    };
};
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
type ApiEndpoint<T extends HttpMethod> = `${T} /api/${string}`;
type JsonValue = string | number | boolean | null | {
    [key: string]: JsonValue;
} | JsonValue[];
type ExtractArrayType<T> = T extends (infer U)[] ? U : never;
type FlattenArray<T> = T extends (infer U)[] ? FlattenArray<U> : T;
declare function merge<T extends object>(target: T, ...sources: Partial<T>[]): T;
declare class Singleton {
    private static instance;
    private constructor();
    static getInstance(): Singleton;
}
declare function asyncGenerator(start: number, end: number): AsyncGenerator<number, void, unknown>;
declare const handler: {
    get(target: any, prop: string): any;
    set(target: any, prop: string, value: any): boolean;
};
declare const proxied: any;
declare function processValue(value: string | number | boolean | null | undefined): string | number;
declare function sql(strings: TemplateStringsArray, ...values: any[]): string;
declare const query: string;
type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type Required<T, K extends keyof T> = T & {
    [P in K]-?: T[P];
};
type CombinedFunction = ((x: number) => number) & ((x: string) => string);
declare enum Status {
    Pending = "pending",
    Processing = "processing",
    Completed = "completed",
    Failed = "failed"
}
declare namespace Utils {
    function formatDate(date: Date): string;
}
declare namespace Utils {
    function formatCurrency(amount: number): string;
}
declare function assertIsString(value: unknown): asserts value is string;
type UserId = string & {
    readonly __brand: unique symbol;
};
type ProductId = string & {
    readonly __brand: unique symbol;
};
declare function createUserId(id: string): UserId;
interface Comparable<T> {
    compareTo(other: T): number;
}
declare function findMax<T extends Comparable<T>>(items: T[]): T | null;
type Exclude<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;
//# sourceMappingURL=edge-cases.d.ts.map