// Generated by dts-bundle v0.7.3
// Dependencies for this module:
//   ../io-ts
//   ../url

declare module 'ethpm' {
    /**
        * @module "ethpm"
        */
    import * as config from "ethpm/config";
    import * as session from "ethpm/session";
    /**
        * This module provides the external interface for configuring an EthPM
        * session object.
        *
        * Usage:
        * ```javascript
        * import EthPM from "ethpm";
        *
        * ```
        */
    export namespace EthPM {
            /**
                * Configure EthPM with specified Node modules to load for various
                * services
                *
                * Example Usage:
                * ```javascript
                * import EthPM from "ethpm";
                * const builder = EthPM.configure({
                *   manifests: "ethpm/manifests/v3",
                *   storage: "ethpm/storage/ipfs",
                *   registries: "ethpm/registries/web3"
                * })
                * ```
                *
                * EthPM.js will `require()` the specified modules from your project's
                * `node_modules/` folder.
                */
            function configure<T extends config.Config>(config: config.RawConfig<T>): session.Builder<T>;
    }
}

declare module 'ethpm/config' {
    /**
      * @module "ethpm/config"
      */
    export * from 'ethpm/config/config';
    export * from 'ethpm/config/loader';
}

declare module 'ethpm/session' {
    /**
      * @module "ethpm/session"
      */
    export * from 'ethpm/session/session';
    export * from 'ethpm/session/query';
}

declare module 'ethpm/config/config' {
    /**
        * @module "ethpm/config"
        */
    import * as t from 'io-ts';
    import * as manifests from "ethpm/manifests/service";
    import * as storage from "ethpm/storage/service";
    import * as registries from "ethpm/registries/service";
    import * as installer from "ethpm/installer/service";
    export type ConfigValue<S = any> = string | (() => Connector<S>) | ({
            default: () => Connector<S>;
    });
    export type HasManifests = {
            manifests: any;
    };
    export type HasStorage = {
            storage: any;
    };
    export type HasRegistries = {
            registries: any;
    };
    export type HasInstaller = {
            installer: any;
    };
    export type Complete = HasManifests & HasStorage & HasRegistries & HasInstaller;
    /**
        * Polymorphic type alias for any object that exposes keys for any or all
        * available services, i.e. `manifests`, `registries`, `storage`, `installer`
        */
    export type Config = HasManifests | HasStorage | HasRegistries | HasInstaller | HasManifests & HasStorage | HasManifests & HasRegistries | HasManifests & HasInstaller | HasStorage & HasRegistries | HasStorage & HasInstaller | HasRegistries & HasInstaller | HasManifests & HasStorage & HasRegistries | HasManifests & HasStorage & HasInstaller | HasManifests & HasRegistries & HasInstaller | HasStorage & HasRegistries & HasInstaller | HasManifests & HasStorage & HasRegistries & HasInstaller;
    export type RawConfig<T extends Config> = {
            [K in keyof T]: ConfigValue<Workspace<T>[K]>;
    } & {
            [k: string]: ConfigValue;
    };
    export abstract class Connector<S> {
            abstract optionsType: any;
            abstract init(...args: any[]): Promise<S>;
            connect(options: t.mixed): Promise<S>;
    }
    export type Workspace<T extends Config> = {
            [K in keyof T]: K extends 'manifests' ? manifests.Service : K extends 'storage' ? storage.Service : K extends 'registries' ? registries.Service : K extends 'installer' ? installer.Service : never;
    };
    export type Connectors<T extends Config> = {
            [K in keyof Workspace<T>]: Connector<Workspace<T>[K]>;
    } & {
            [k: string]: Connector<any>;
    };
}

declare module 'ethpm/config/loader' {
    /**
      * @module "ethpm/config"
      */
    import * as config from 'ethpm/config/config';
    export function load<S>(plugin: config.ConfigValue<S>): config.Connector<S>;
}

declare module 'ethpm/session/session' {
    /**
      * @module "ethpm/session"
      */
    import * as config from "ethpm/config";
    import { Config, HasInstaller, HasManifests, HasStorage, HasRegistries } from "ethpm/config";
    import * as pkg from "ethpm/package";
    import { Query } from 'ethpm/session/query';
    export class Builder<T extends config.Config> {
        constructor(config_: config.RawConfig<T>);
        connect(options?: any): Promise<Session<T>>;
    }
    export class Session<T extends Config> {
        constructor(workspace: config.Workspace<T>);
        query(package_: pkg.Package): Query<T>;
        get manifests(): config.Workspace<HasManifests>['manifests'] | never;
        get storage(): config.Workspace<HasStorage>['storage'] | never;
        get installer(): config.Workspace<HasInstaller>['installer'] | never;
        get registries(): config.Workspace<HasRegistries>['registries'] | never;
    }
}

declare module 'ethpm/session/query' {
    /**
      * @module "ethpm/session"
      */
    import * as config from "ethpm/config";
    import * as pkg from "ethpm/package";
    export class Query<T extends config.Config> {
        package: pkg.Package;
        constructor(options: {
            package: pkg.Package;
            workspace: config.Workspace<T>;
        });
        scope(dependencyName: pkg.PackageName): Promise<Query<T>>;
        contractType(ref: pkg.ContractTypeReference): Promise<pkg.ContractType>;
        contractInstance(chain: pkg.ChainURI, name: pkg.ContractInstanceName): Promise<pkg.ContractInstance>;
        buildDependency(name: pkg.PackageName): Promise<pkg.Package> | never;
    }
}

declare module 'ethpm/manifests/service' {
    /**
      * @module "ethpm/manifests"
      */
    import { Package } from "ethpm/package";
    export interface Service {
        read(json: string): Promise<Package>;
        write(pkg: Package): Promise<string>;
    }
}

declare module 'ethpm/storage/service' {
    /**
      * @module "ethpm/storage"
      */
    import { Maybe } from "ethpm/types";
    import { URL } from 'url';
    export interface Service {
        read(uri: URL): Promise<Maybe<string>>;
        hash(content: string): Promise<string>;
        predictUri(content: string): Promise<URL>;
        write(content: string): Promise<URL>;
    }
}

declare module 'ethpm/registries/service' {
    /**
        * @module "ethpm/registries"
        */
    import { URL } from 'url';
    import * as pkg from "ethpm/package";
    export interface Service {
            /**
                * List all packages
                */
            packages(): Promise<pkg.PackageName[]>;
            /**
                * Query a particular package
                */
            package(packageName: pkg.PackageName): {
                    /**
                        * List all releases
                        */
                    releases(): Promise<object>;
                    /**
                        * Retrieve manifest URI for specific version
                        */
                    release(version: pkg.Version): Promise<URL>;
            };
            /**
                * Publish a release
                */
            publish(packageName: pkg.PackageName, version: pkg.Version, manifest: URL): Promise<any>;
    }
}

declare module 'ethpm/installer/service' {
    /**
      * @module "ethpm/installer"
      */
    import { URL } from "url";
    export interface Service {
        install(contentURI: URL, registryAddress: string): Promise<void>;
    }
}

declare module 'ethpm/package' {
    /**
      * @module "ethpm/package"
      */
    export * from 'ethpm/package/package';
    export * from 'ethpm/package/link';
    export * from 'ethpm/package/meta';
}

declare module 'ethpm/types' {
    /**
      * @module "ethpm/types"
      */
    export type Maybe<T> = T | undefined;
    export function maybe<T>(t: T | undefined): Maybe<T>;
    export function lift<T, U>(func: (t: T) => U): (t: Maybe<T>) => U | undefined;
    export function lift2<T, U, V>(func: (t: T, u: U) => V): (t: Maybe<T>, u: Maybe<U>) => V | undefined;
}

declare module 'ethpm/package/package' {
    /**
      * @module "ethpm/package"
      */
    import { URL } from 'url';
    import { Maybe } from "ethpm/types";
    import { Meta } from 'ethpm/package/meta';
    import { Link } from 'ethpm/package/link';
    export type Address = string;
    export type TransactionHash = string;
    export type BlockHash = string;
    export type PackageName = string;
    export type Manifest = string;
    export type Version = string;
    export type RelativePath = string;
    export type ChainURI = URL;
    export type ContentURI = URL;
    export type SourceString = string;
    export type ContractAlias = string;
    export type ContractName = string;
    export type ContractTypeReference = string;
    export type ContractInstanceName = string;
    export type bytecode = string;
    export type CompilerName = string;
    export type CompilerVersion = string;
    export type CompilerSettings = any;
    export type ABI = Array<any>;
    export type Devdoc = object;
    export type Userdoc = object;
    export interface Compiler {
        name: CompilerName;
        version: CompilerVersion;
        settings?: CompilerSettings;
        contractTypes?: Array<ContractTypeReference>;
    }
    export interface Bytecode {
        bytecode: bytecode;
        linkReferences: Array<Link.Reference>;
        linkDependencies: Array<Link.Value>;
    }
    export interface ContractType {
        contractName: ContractName;
        deploymentBytecode: Maybe<Bytecode>;
        runtimeBytecode: Maybe<Bytecode>;
        abi: Maybe<ABI>;
        devdoc: Maybe<Devdoc>;
        userdoc: Maybe<Userdoc>;
        sourceId: Maybe<SourceId>;
    }
    export interface ContractInstance {
        contractType: ContractTypeReference;
        address: Address;
        transaction: Maybe<TransactionHash>;
        block: Maybe<BlockHash>;
        runtimeBytecode: Maybe<Bytecode>;
    }
    export type SourceId = string;
    export interface SourceWithUrls {
        type: Maybe<string>;
        installPath: Maybe<RelativePath>;
        urls: Array<ContentURI>;
    }
    export interface SourceWithContent {
        type: Maybe<string>;
        installPath: Maybe<RelativePath>;
        content: SourceString;
    }
    export type Sources = Record<SourceId, SourceWithContent> | Record<SourceId, SourceWithUrls>;
    export type ContractTypes = Record<ContractAlias, ContractType>;
    export type Compilers = Array<Compiler>;
    export type Deployment = Record<ContractInstanceName, ContractInstance>;
    export type Deployments = Map<ChainURI, Deployment>;
    export type BuildDependencies = Record<PackageName, ContentURI>;
    export interface Package {
        packageName: Maybe<PackageName>;
        version: Maybe<Version>;
        manifest: Manifest;
        meta: Meta.PackageMeta;
        sources: Sources;
        compilers: Compilers;
        contractTypes: ContractTypes;
        deployments: Deployments;
        buildDependencies: BuildDependencies;
    }
}

declare module 'ethpm/package/link' {
    /**
      * @module "ethpm/package"
      */
    export namespace Link {
        type Offset = number;
        type Length = number;
        type Name = string;
        interface Literal {
            type: 'literal';
            value: string;
        }
        interface InstanceReference {
            type: 'reference';
            value: string;
        }
        interface Reference {
            offsets: Array<Offset>;
            length: Length;
            name: Name;
        }
        interface Value {
            offsets: Array<Offset>;
            value: Literal | InstanceReference;
        }
    }
}

declare module 'ethpm/package/meta' {
    /**
      * @module "ethpm/package"
      */
    export namespace Meta {
        type Author = string;
        type License = string;
        type Description = string;
        type Keyword = string;
        interface PackageMetaLink {
            resource: string;
            uri: string;
        }
        interface PackageMeta {
            authors?: Array<Author>;
            license?: License;
            description?: Description;
            keywords?: Array<Keyword>;
            links?: Array<PackageMetaLink>;
        }
    }
}