import * as API from "../../common/api";
import { CollectionDoc, Events, NewTask, QueryParams, Resource, ResourceId, Scope, SingleDoc, State, Task } from "../../common/structures";
import * as Accounts from "../accounts";
import * as Dns from "../dns";
import * as Images from "../images";
import * as Plans from "../plans";
import * as Instances from "./instances";
export declare function document(): typeof CollectionRequest;
export declare function document(id: ResourceId): SingleRequest;
export interface Collection extends CollectionDoc {
    data: Container[];
    includes?: {
        images: {
            [key: string]: Images.Image;
        };
        plans: {
            [key: string]: Plans.Plan;
        };
    };
}
export interface Single extends SingleDoc {
    data: Container | null;
    includes?: {
        images: {
            [key: string]: Images.Image;
        };
        plans: {
            [key: string]: Plans.Plan;
        };
        domains: {
            [key: string]: Dns.Records.Record;
        };
    };
}
export interface Container extends Resource {
    name: string;
    config: Config;
    volumes: Volume[];
    state: State<ContainerState>;
    events: Events;
    creator?: string;
    owner: Scope;
    environment: ResourceId;
    image?: ResourceId;
    plan: ResourceId;
    domain: ResourceId;
    stats?: Stats;
    meta?: {
        instances?: {
            starting: number;
            running: number;
            stopping: number;
            stopped: number;
            deleting: number;
            deleted: number;
        };
        public_ip?: {
            address: string;
            mask: string;
        };
    };
}
export interface Service {
    role: "" | "dns";
}
export declare type ContainerState = "starting" | "running" | "stopping" | "stopped" | "deleting" | "deleted";
export declare type SingleActions = "start" | "stop" | "apply" | "reimage";
export interface ApplyTaskParams {
    plan?: ResourceId;
    domain?: ResourceId | null;
    runtime?: RuntimeConfig;
    tls?: TLS;
    flags?: Flags;
    hostname?: string;
    scaling?: {
        geodns?: Partial<GeoDNS>;
        loadbalance?: Partial<LoadBalance>;
        persistent?: Partial<Persistent>;
    };
}
export interface ReimageParams {
    image: ResourceId;
}
export interface Config {
    flags: Flags;
    tls?: TLS;
    dnsrecord: ResourceId | null;
    runtime?: RuntimeConfig;
    hostname: string;
    scaling: Scaling;
    service?: Service;
}
export interface Stats {
    spawns: number;
}
export interface Flags {
    auto_restart: boolean;
}
export interface RuntimeConfig {
    env_vars?: {
        [key: string]: string;
    };
    command?: {
        args: string[];
        override: boolean;
    };
}
export declare type Scaling = GeoDNS | LoadBalance | Persistent;
export declare type ScalingMethodName = "geodns" | "loadbalance" | "persistent";
export interface GeoDNS {
    method: "geodns";
    geodns: {
        datacenters: ResourceId[];
        max_per_dc: number;
        min_per_dc: number;
    };
}
export interface LoadBalance {
    method: "loadbalance";
    loadbalance: {
        datacenter: ResourceId;
        max: number;
        min: number;
    };
}
export interface Persistent {
    method: "persistent";
    persistent: {
        datacenter: string;
        public_interface: boolean;
    };
}
export interface Volume {
    id: ResourceId;
    volume_plan: string;
    path: string;
    remote_access: boolean;
}
export interface TLS {
    enabled: boolean;
    path: string;
}
export interface NewParams {
    name: string;
    environment: ResourceId;
    config: Partial<Config>;
    plan: ResourceId;
    image: ResourceId;
    volumes: Volume[];
}
export interface UpdateParams {
    name?: string;
    volumes?: Array<{
        id: ResourceId;
        remote_access: boolean;
    }>;
}
export interface EventCollection extends CollectionDoc {
    data: Event[];
    includes?: {
        creators: {
            [key: string]: Accounts.Account;
        };
    };
}
export interface Event {
    id: ResourceId;
    type: string;
    caption: string;
    time: string;
    platform: boolean;
    creator: ResourceId;
    container: ResourceId;
    instance?: ResourceId;
}
export interface CompatibleImages extends Images.Collection {
}
export declare class CollectionRequest {
    private static target;
    static get(query?: QueryParams): Promise<API.ApiResult<Collection>>;
    static create(doc: NewParams, query?: QueryParams): Promise<API.ApiResult<Single>>;
}
export declare class SingleRequest {
    private id;
    private target;
    constructor(id: ResourceId);
    get(query?: QueryParams): Promise<API.ApiResult<Single>>;
    update(doc: UpdateParams, query?: QueryParams): Promise<API.ApiResult<Single>>;
    delete(query?: QueryParams): Promise<API.ApiResult<Task<SingleActions>>>;
    start(): Promise<API.ApiResult<Task<SingleActions>>>;
    stop(): Promise<API.ApiResult<Task<SingleActions>>>;
    apply(mods: ApplyTaskParams): Promise<API.ApiResult<Task<SingleActions>>>;
    reimage(params: ReimageParams): Promise<API.ApiResult<Task<SingleActions>>>;
    compatibleImages(query?: QueryParams): Promise<API.ApiResult<CompatibleImages>>;
    task(t: NewTask<SingleActions>, query?: QueryParams): Promise<API.ApiResult<Task<SingleActions>>>;
    events(query?: QueryParams): Promise<API.ApiResult<EventCollection>>;
    instances(): Instances.CollectionRequest;
    instances(id: ResourceId): Instances.SingleRequest;
}