import * as preact from 'preact';
export * from 'renderer';

declare global {
	interface SymbolConstructor {
		readonly observable: symbol;
	}
}

/**
Create a type from an object type without certain keys.

This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.

Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/30825) if you want to have the stricter version as a built-in in TypeScript.

@example
```
import {Except} from 'type-fest';

type Foo = {
	a: number;
	b: string;
	c: boolean;
};

type FooWithoutA = Except<Foo, 'a' | 'c'>;
//=> {b: string};
```
*/
type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;

/**
Flatten the type output to improve type hints shown in editors.
*/
type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

/**
Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.

Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.

@example
```
import {SetRequired} from 'type-fest';

type Foo = {
	a?: number;
	b: string;
	c?: boolean;
}

type SomeRequired = SetRequired<Foo, 'b' | 'c'>;
// type SomeRequired = {
// 	a?: number;
// 	b: string; // Was already required and still is.
// 	c: boolean; // Is now required.
// }
```
*/
type SetRequired<BaseType, Keys extends keyof BaseType> =
	Simplify<
		// Pick just the keys that are optional from the base type.
		Except<BaseType, Keys> &
		// Pick the keys that should be required from the base type and make them required.
		Required<Pick<BaseType, Keys>>
	>;

interface NavLink {
    text: string;
    link: string;
}
interface Options {
    title?: string;
    indexFile?: string;
    root?: string;
    highlight?: boolean;
    highlightLanguages?: string[];
    navLinks?: NavLink[];
    props?: any;
    font?: string;
    base?: string;
    useSystemTheme?: boolean;
    beforeSidebar?: string;
}
declare type InstanceOptions = SetRequired<Options, 'indexFile' | 'root' | 'highlight' | 'title' | 'base'>;
declare class Docup {
    options: InstanceOptions;
    constructor(options?: Options);
    init(): void;
}
declare function init(options: Options): void;
declare const version: string;

declare const html: (strings: TemplateStringsArray, ...values: any[]) => preact.VNode<any> | preact.VNode<any>[];

export { Docup, InstanceOptions, NavLink, Options, html, init, version };