// tslint:disable
import fetch from 'node-fetch';
import { RequestInit, Response } from 'node-fetch';
import AbortController from 'abort-controller';
import { createReturnTypeValidator, ClassValidator, ValidationError } from './common';
import {
  schema,
  InternalServerError,
  UnauthorizedError,
  NotFoundError,
  ExistsError,
  Session,
  ServerOnlyContext,
  SubDomain,
  CNameDomain,
  TemplateSource,
  Environment,
  Application,
  Template,
  ExternalAccount,
  User,
  InvocationDetails,
  LogRecord,
  LogReadOpts,
  LogsResponse,
  CreateTicketResponse,
  TryTemplateResponse,
  TemplateData,
  InitialData,
  Lycan,
  InteractionEvent,
  ViewEvent,
  FunctionRunnerSize,
  Domain,
  Serializable,
} from './interfaces';

export interface Options extends Pick<RequestInit, 'agent' | 'redirect' | 'follow' | 'compress'> {
  fetchImplementation?: typeof fetch;
  timeoutMs?: number;
  headers?: Record<string, string>;
}

export class RequestError extends Error {
  public readonly name = 'RequestError';
  constructor(
    message: string,
    /**
     * The original error causing this request to fail
     * Inherits Error in case of network or parse errors
     * In case of an invalid HTTP response it will contain an object with the body/trimmed text of the response
     */
    public readonly cause: any,
    public readonly method: string,
    public readonly options: any
  ) {
    super(message);
  }
}

export class TimeoutError extends Error {
  public readonly name = 'TimeoutError';
  constructor(message: string, public readonly method: string, public readonly options: any) {
    super(message);
  }
}

export {
  ValidationError,
};




















export interface Lycan {
  createTicket(): Promise<CreateTicketResponse>;
  claimTicket(ticket: string): Promise<string>;
  listTemplates(): Promise<Array<Template>>;
  reportAnalytics(events: Array<(InteractionEvent) | (ViewEvent)>): Promise<void>;
  tryTemplate(id: string): Promise<TryTemplateResponse>;
  whoami(): Promise<User>;
  listApps(): Promise<Array<Application>>;
  getApp(id: string): Promise<Application>;
  getAppByName(name: string): Promise<Application>;
  deployInitial(env: string, digest: string, envVars: Array<[string, string]>): Promise<Application>;
  deploy(appId: string, env: string, digest: string, envVars: Array<[string, string]>): Promise<Application>;
  claimApp(token: string): Promise<Application>;
  getLogs(appId: string, env: string, opts: LogReadOpts): Promise<LogsResponse>;
  getLogsByName(name: string, env: string, opts: LogReadOpts): Promise<LogsResponse>;
  destroyApp(appId: string): Promise<void>;
  destroyAppByName(name: string): Promise<void>;
}

export class LycanClient {
  public static readonly methods = [
    'createTicket',
    'claimTicket',
    'listTemplates',
    'reportAnalytics',
    'tryTemplate',
    'whoami',
    'listApps',
    'getApp',
    'getAppByName',
    'deployInitial',
    'deploy',
    'claimApp',
    'getLogs',
    'getLogsByName',
    'destroyApp',
    'destroyAppByName',
  ];
  public static readonly validators: ClassValidator = createReturnTypeValidator(schema, 'Lycan');

  protected readonly props = schema.definitions.Lycan.properties;

  public readonly validators: ClassValidator; // We don't have class name in method scope because mustache sux

  public constructor(public readonly serverUrl: string, protected readonly options: Options = {}) {
    this.validators = LycanClient.validators;
  }

  public async createTicket(options?: Options): Promise<CreateTicketResponse> {
    const body = {
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/createTicket`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'createTicket', mergedOptions);
      }
      throw new RequestError(err.message, err, 'createTicket', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.createTicket;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as CreateTicketResponse;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'createTicket',
      mergedOptions);
  }

  public async claimTicket(ticket: string, options?: Options): Promise<string> {
    const body = {
      ticket,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/claimTicket`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'claimTicket', mergedOptions);
      }
      throw new RequestError(err.message, err, 'claimTicket', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.claimTicket;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as string;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'claimTicket',
      mergedOptions);
  }

  public async listTemplates(options?: Options): Promise<Array<Template>> {
    const body = {
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/listTemplates`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'listTemplates', mergedOptions);
      }
      throw new RequestError(err.message, err, 'listTemplates', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.listTemplates;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Array<Template>;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'listTemplates',
      mergedOptions);
  }

  public async reportAnalytics(events: Array<(InteractionEvent) | (ViewEvent)>, options?: Options): Promise<void> {
    const body = {
      events,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/reportAnalytics`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'reportAnalytics', mergedOptions);
      }
      throw new RequestError(err.message, err, 'reportAnalytics', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.reportAnalytics;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as void;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'reportAnalytics',
      mergedOptions);
  }

  public async tryTemplate(id: string, options?: Options): Promise<TryTemplateResponse> {
    const body = {
      id,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/tryTemplate`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'tryTemplate', mergedOptions);
      }
      throw new RequestError(err.message, err, 'tryTemplate', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.tryTemplate;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as TryTemplateResponse;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'tryTemplate',
      mergedOptions);
  }

  public async whoami(options?: Options): Promise<User> {
    const body = {
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/whoami`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'whoami', mergedOptions);
      }
      throw new RequestError(err.message, err, 'whoami', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.whoami;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as User;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'whoami',
      mergedOptions);
  }

  public async listApps(options?: Options): Promise<Array<Application>> {
    const body = {
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/listApps`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'listApps', mergedOptions);
      }
      throw new RequestError(err.message, err, 'listApps', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.listApps;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Array<Application>;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'listApps',
      mergedOptions);
  }

  public async getApp(id: string, options?: Options): Promise<Application> {
    const body = {
      id,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/getApp`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'getApp', mergedOptions);
      }
      throw new RequestError(err.message, err, 'getApp', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.getApp;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Application;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'getApp',
      mergedOptions);
  }

  public async getAppByName(name: string, options?: Options): Promise<Application> {
    const body = {
      name,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/getAppByName`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'getAppByName', mergedOptions);
      }
      throw new RequestError(err.message, err, 'getAppByName', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.getAppByName;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Application;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'getAppByName',
      mergedOptions);
  }

  public async deployInitial(env: string, digest: string, envVars: Array<[string, string]>, options?: Options): Promise<Application> {
    const body = {
      env,
      digest,
      envVars,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/deployInitial`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'deployInitial', mergedOptions);
      }
      throw new RequestError(err.message, err, 'deployInitial', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.deployInitial;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Application;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'ExistsError') {
        throw new ExistsError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'deployInitial',
      mergedOptions);
  }

  public async deploy(appId: string, env: string, digest: string, envVars: Array<[string, string]>, options?: Options): Promise<Application> {
    const body = {
      appId,
      env,
      digest,
      envVars,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/deploy`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'deploy', mergedOptions);
      }
      throw new RequestError(err.message, err, 'deploy', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.deploy;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Application;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'deploy',
      mergedOptions);
  }

  public async claimApp(token: string, options?: Options): Promise<Application> {
    const body = {
      token,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/claimApp`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'claimApp', mergedOptions);
      }
      throw new RequestError(err.message, err, 'claimApp', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.claimApp;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as Application;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'claimApp',
      mergedOptions);
  }

  public async getLogs(appId: string, env: string, opts: LogReadOpts, options?: Options): Promise<LogsResponse> {
    const body = {
      appId,
      env,
      opts,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/getLogs`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'getLogs', mergedOptions);
      }
      throw new RequestError(err.message, err, 'getLogs', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.getLogs;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as LogsResponse;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'getLogs',
      mergedOptions);
  }

  public async getLogsByName(name: string, env: string, opts: LogReadOpts, options?: Options): Promise<LogsResponse> {
    const body = {
      name,
      env,
      opts,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/getLogsByName`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'getLogsByName', mergedOptions);
      }
      throw new RequestError(err.message, err, 'getLogsByName', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.getLogsByName;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as LogsResponse;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'getLogsByName',
      mergedOptions);
  }

  public async destroyApp(appId: string, options?: Options): Promise<void> {
    const body = {
      appId,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/destroyApp`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'destroyApp', mergedOptions);
      }
      throw new RequestError(err.message, err, 'destroyApp', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.destroyApp;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as void;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'destroyApp',
      mergedOptions);
  }

  public async destroyAppByName(name: string, options?: Options): Promise<void> {
    const body = {
      name,
    };

    const mergedOptions = {
      serverUrl: this.serverUrl,
      ...this.options,
      ...options,
    };

    const { fetchImplementation, timeoutMs, headers, serverUrl, ...fetchOptions } = mergedOptions;

    const fetchImpl = fetchImplementation || fetch;

    let timeout: NodeJS.Timeout | undefined;
    if (timeoutMs) {
      const controller = new AbortController();
      timeout = setTimeout(() => controller.abort(), timeoutMs);
      (fetchOptions as any).signal = controller.signal;
    }

    let response: Response;
    let responseBody: any;
    let responseText: string | undefined;
    let isJSON: boolean;
    try {
      response = await fetchImpl(`${serverUrl}/destroyAppByName`, {
        ...fetchOptions,
        headers: {
          ...headers,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify(body),
        method: 'POST',
      });
      isJSON = (response.headers.get('content-type') || '').startsWith('application/json');
      if (isJSON) {
        responseBody = await response.json();
      } else {
        responseText = await response.text();
      }
    } catch (err) {
      if (err.message === 'The user aborted a request.') {
        timeout = undefined;
        throw new TimeoutError('Request aborted due to timeout', 'destroyAppByName', mergedOptions);
      }
      throw new RequestError(err.message, err, 'destroyAppByName', mergedOptions);
    } finally {
      if (timeout) clearTimeout(timeout);
    }
    if (response.status >= 200 && response.status < 300) {
      const validator = this.validators.destroyAppByName;
      const wrapped = { returns: responseBody }; // wrapped for coersion
      if (!validator(wrapped)) {
        throw new ValidationError('Failed to validate response', validator.errors);
      }
      return wrapped.returns as void;
    } else if (!isJSON) {
      // fall through to throw
    } else if (response.status === 400) {
      if (responseBody.name === 'ValidationError') {
        throw new ValidationError(responseBody.message, responseBody.errors);
      }
    } else if (response.status === 500) {
      if (responseBody.name === 'UnauthorizedError') {
        throw new UnauthorizedError(responseBody.message);
      }
      if (responseBody.name === 'NotFoundError') {
        throw new NotFoundError(responseBody.message);
      }
      throw new InternalServerError(responseBody.message);
    }
    throw new RequestError(`${response.status} - ${response.statusText}`,
      { responseText: responseText && responseText.slice(0, 256), responseBody },
      'destroyAppByName',
      mergedOptions);
  }
}