import * as url from 'url';

declare namespace io.apibuilder.common.v0.enums {
  type MembershipRole = 'member' | 'admin';
}

declare namespace io.apibuilder.common.v0.models {
  interface Audit {
    readonly 'created_at': string;
    readonly 'created_by': io.apibuilder.common.v0.models.ReferenceGuid;
    readonly 'updated_at': string;
    readonly 'updated_by': io.apibuilder.common.v0.models.ReferenceGuid;
  }

  interface Healthcheck {
    readonly 'status': string;
  }

  interface Reference {
    readonly 'guid': string;
    readonly 'key': string;
  }

  interface ReferenceGuid {
    readonly 'guid': string;
  }
}

declare namespace io.apibuilder.spec.v0.enums {
  type Method = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'CONNECT' | 'OPTIONS' | 'TRACE';
  type ParameterLocation = 'Path' | 'Query' | 'Form' | 'Header';
  type ResponseCodeOption = 'Default';
}

declare namespace io.apibuilder.spec.v0.models {
  interface Annotation {
    readonly 'name': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
  }

  interface Apidoc {
    readonly 'version': string;
  }

  interface Application {
    readonly 'key': string;
  }

  interface Attribute {
    readonly 'name': string;
    readonly 'value': any/*object*/;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
  }

  interface Body {
    readonly 'type': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Contact {
    readonly 'name'?: string;
    readonly 'url'?: string;
    readonly 'email'?: string;
  }

  interface Deprecation {
    readonly 'description'?: string;
  }

  interface Enum {
    readonly 'name': string;
    readonly 'plural': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'values': io.apibuilder.spec.v0.models.EnumValue[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface EnumValue {
    readonly 'name': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'value'?: string;
  }

  interface Field {
    readonly 'name': string;
    readonly 'type': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'default'?: string;
    readonly 'required': boolean;
    readonly 'minimum'?: number;
    readonly 'maximum'?: number;
    readonly 'example'?: string;
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'annotations': string[];
  }

  interface Header {
    readonly 'name': string;
    readonly 'type': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'required': boolean;
    readonly 'default'?: string;
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Import {
    readonly 'uri': string;
    readonly 'namespace': string;
    readonly 'organization': io.apibuilder.spec.v0.models.Organization;
    readonly 'application': io.apibuilder.spec.v0.models.Application;
    readonly 'version': string;
    readonly 'enums': string[];
    readonly 'interfaces': string[];
    readonly 'unions': string[];
    readonly 'models': string[];
    readonly 'annotations': io.apibuilder.spec.v0.models.Annotation[];
  }

  interface Info {
    readonly 'license'?: io.apibuilder.spec.v0.models.License;
    readonly 'contact'?: io.apibuilder.spec.v0.models.Contact;
  }

  interface Interface {
    readonly 'name': string;
    readonly 'plural': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'fields': io.apibuilder.spec.v0.models.Field[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface License {
    readonly 'name': string;
    readonly 'url'?: string;
  }

  interface Model {
    readonly 'name': string;
    readonly 'plural': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'fields': io.apibuilder.spec.v0.models.Field[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'interfaces': string[];
  }

  interface Operation {
    readonly 'method': io.apibuilder.spec.v0.enums.Method;
    readonly 'path': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'body'?: io.apibuilder.spec.v0.models.Body;
    readonly 'parameters': io.apibuilder.spec.v0.models.Parameter[];
    readonly 'responses': io.apibuilder.spec.v0.models.Response[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Organization {
    readonly 'key': string;
  }

  interface Parameter {
    readonly 'name': string;
    readonly 'type': string;
    readonly 'location': io.apibuilder.spec.v0.enums.ParameterLocation;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'required': boolean;
    readonly 'default'?: string;
    readonly 'minimum'?: number;
    readonly 'maximum'?: number;
    readonly 'example'?: string;
    readonly 'attributes'?: io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Resource {
    readonly 'type': string;
    readonly 'plural': string;
    readonly 'path'?: string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'operations': io.apibuilder.spec.v0.models.Operation[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Response {
    readonly 'code': io.apibuilder.spec.v0.unions.ResponseCode;
    readonly 'type': string;
    readonly 'headers'?: io.apibuilder.spec.v0.models.Header[];
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'attributes'?: io.apibuilder.spec.v0.models.Attribute[];
  }

  interface Service {
    readonly 'apidoc'?: io.apibuilder.spec.v0.models.Apidoc;
    readonly 'name': string;
    readonly 'organization': io.apibuilder.spec.v0.models.Organization;
    readonly 'application': io.apibuilder.spec.v0.models.Application;
    readonly 'namespace': string;
    readonly 'version': string;
    readonly 'base_url'?: string;
    readonly 'description'?: string;
    readonly 'info': io.apibuilder.spec.v0.models.Info;
    readonly 'headers': io.apibuilder.spec.v0.models.Header[];
    readonly 'imports': io.apibuilder.spec.v0.models.Import[];
    readonly 'enums': io.apibuilder.spec.v0.models.Enum[];
    readonly 'interfaces': io.apibuilder.spec.v0.models.Interface[];
    readonly 'unions': io.apibuilder.spec.v0.models.Union[];
    readonly 'models': io.apibuilder.spec.v0.models.Model[];
    readonly 'resources': io.apibuilder.spec.v0.models.Resource[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'annotations': io.apibuilder.spec.v0.models.Annotation[];
  }

  interface Union {
    readonly 'name': string;
    readonly 'plural': string;
    readonly 'discriminator'?: string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'types': io.apibuilder.spec.v0.models.UnionType[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'interfaces': string[];
  }

  interface UnionType {
    readonly 'type': string;
    readonly 'description'?: string;
    readonly 'deprecation'?: io.apibuilder.spec.v0.models.Deprecation;
    readonly 'fields'?: io.apibuilder.spec.v0.models.Field[];
    readonly 'attributes': io.apibuilder.spec.v0.models.Attribute[];
    readonly 'default'?: boolean;
    readonly 'discriminator_value'?: string;
  }
}

declare namespace io.apibuilder.spec.v0.unions {
  type ResponseCode = ({
    discriminator: 'integer',
    value: number
  } | {
    discriminator: 'response_code_option',
    value: io.apibuilder.spec.v0.enums.ResponseCodeOption
  });
}

declare namespace io.apibuilder.generator.v0.enums {
  type FileFlag = 'scaffolding';
}

declare namespace io.apibuilder.generator.v0.models {
  interface Attribute {
    readonly 'name': string;
    readonly 'value': string;
  }

  interface Error {
    readonly 'code': string;
    readonly 'message': string;
  }

  interface File {
    readonly 'name': string;
    readonly 'dir'?: string;
    readonly 'contents': string;
    readonly 'flags'?: io.apibuilder.generator.v0.enums.FileFlag[];
  }

  interface Generator {
    readonly 'key': string;
    readonly 'name': string;
    readonly 'language'?: string;
    readonly 'description'?: string;
    readonly 'attributes': string[];
  }

  interface Healthcheck {
    readonly 'status': string;
  }

  interface Invocation {
    readonly 'source': string;
    readonly 'files': io.apibuilder.generator.v0.models.File[];
  }

  interface InvocationForm {
    readonly 'service': io.apibuilder.spec.v0.models.Service;
    readonly 'attributes': io.apibuilder.generator.v0.models.Attribute[];
    readonly 'user_agent'?: string;
    readonly 'imported_services'?: io.apibuilder.spec.v0.models.Service[];
  }
}

declare namespace payp.mard2p.api.v0.enums {
  type AppSortBy = 'created' | 'edited';
  type OriginalType = 'api_json';
  type Publication = 'membership_requests.create' | 'memberships.create' | 'applications.create' | 'versions.create';
  type SortOrder = 'asc' | 'desc';
  type Visibility = 'public';
}

declare namespace payp.mard2p.api.v0.models {
  interface Account {
    readonly 'accountid': number;
    readonly 'ownerid': string;
    readonly 'total_amount': number;
    readonly 'currency': string;
    readonly 'sold': number;
    readonly 'debit': number;
  }

  interface AccountForm {
    readonly 'accountid': number;
    readonly 'ownerid': string;
    readonly 'total_amount'?: number;
    readonly 'sold': number;
    readonly 'debit'?: number;
    readonly 'currency': string;
  }

  interface Deposit {
    readonly 'depid': number;
    readonly 'paymentid': number;
  }

  interface Payment {
    readonly 'payid': number;
    readonly 'actorid': string;
    readonly 'amount': number;
    readonly 'ref_accountid': number;
    readonly 'payment_method': string;
    readonly 'operatorid': string;
    readonly 'phone': number;
    readonly 'pin': number;
    readonly 'currency': string;
    readonly 'payment_context': string;
  }

  interface PaymentForm {
    readonly 'payid': number;
    readonly 'actorid': string;
    readonly 'amount': number;
    readonly 'ref_accountid': number;
    readonly 'payment_method': string;
    readonly 'operatorid': string;
    readonly 'phone': number;
    readonly 'pin': number;
    readonly 'currency': string;
    readonly 'payment_context': string;
  }

  interface Transfer {
    readonly 'transferid': number;
    readonly 'senderid': string;
    readonly 'amount': number;
    readonly 'ref_accountid_receiver': number;
    readonly 'ref_accountid_sender': number;
    readonly 'currency': string;
  }

  interface TransferForm {
    readonly 'transferid': number;
    readonly 'senderid': string;
    readonly 'amount': number;
    readonly 'ref_accountid_receiver': number;
    readonly 'ref_accountid_sender': number;
    readonly 'currency': string;
  }

  interface Validation {
    readonly 'valid': boolean;
    readonly 'errors': string[];
  }

  interface Withdraw {
    readonly 'wdwid': number;
    readonly 'paymentid': number;
  }
}

export type Account = payp.mard2p.api.v0.models.Account;
export type AccountForm = payp.mard2p.api.v0.models.AccountForm;
export type AppSortBy = payp.mard2p.api.v0.enums.AppSortBy;
export type Deposit = payp.mard2p.api.v0.models.Deposit;
export type OriginalType = payp.mard2p.api.v0.enums.OriginalType;
export type Payment = payp.mard2p.api.v0.models.Payment;
export type PaymentForm = payp.mard2p.api.v0.models.PaymentForm;
export type Publication = payp.mard2p.api.v0.enums.Publication;
export type SortOrder = payp.mard2p.api.v0.enums.SortOrder;
export type Transfer = payp.mard2p.api.v0.models.Transfer;
export type TransferForm = payp.mard2p.api.v0.models.TransferForm;
export type Validation = payp.mard2p.api.v0.models.Validation;
export type Visibility = payp.mard2p.api.v0.enums.Visibility;
export type Withdraw = payp.mard2p.api.v0.models.Withdraw;

export interface $FetchOptions {
  body?: string;
  headers?: $HttpHeaders;
  method?: $HttpMethod;
}

export type $FetchFunction = (url: string, options?: $FetchOptions) => Promise<Response>;

export interface $HttpHeaders {
  [key: string]: string;
}

export type $HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'CONNECT' | 'OPTIONS' | 'TRACE';

export interface $HttpQuery {
  [key: string]: string | number | boolean | string[] | number[] | boolean[] | undefined | null;
}

export interface $HttpRequest {
  body?: any;
  url: string;
  headers: $HttpHeaders;
  method: $HttpMethod;
}

export interface $HttpRequestOptions {
  body?: any;
  endpoint: string;
  headers?: $HttpHeaders;
  method: $HttpMethod;
  query?: $HttpQuery;
}

export interface $HttpResponse<B = any, S = number, O = boolean> {
  body: B;
  headers: $HttpHeaders;
  ok: O;
  request: $HttpRequest;
  status: S;
  statusText: string;
}

export type $HttpContinue<T> = $HttpResponse<T, 100, false>;
export type $HttpSwitchingProtocol<T> = $HttpResponse<T, 101, false>;
export type $HttpProcessing<T> = $HttpResponse<T, 102, false>;
export type $HttpOk<T> = $HttpResponse<T, 200, true>;
export type $HttpCreated<T> = $HttpResponse<T, 201, true>;
export type $HttpAccepted<T> = $HttpResponse<T, 202, true>;
export type $HttpNonAuthoritativeInformation<T> = $HttpResponse<T, 203, true>;
export type $HttpNoContent<T> = $HttpResponse<T, 204, true>;
export type $HttpResetContent<T> = $HttpResponse<T, 205, true>;
export type $HttpPartialContent<T> = $HttpResponse<T, 206, true>;
export type $HttpMultiStatus<T> = $HttpResponse<T, 207, true>;
export type $HttpAlreadyReported<T> = $HttpResponse<T, 208, true>;
export type $HttpImUsed<T> = $HttpResponse<T, 226, true>;
export type $HttpMultipleChoices<T> = $HttpResponse<T, 300, false>;
export type $HttpMovedPermanently<T> = $HttpResponse<T, 301, false>;
export type $HttpFound<T> = $HttpResponse<T, 302, false>;
export type $HttpSeeOther<T> = $HttpResponse<T, 303, false>;
export type $HttpNotModified<T> = $HttpResponse<T, 304, false>;
export type $HttpUseProxy<T> = $HttpResponse<T, 305, false>;
export type $HttpTemporaryRedirect<T> = $HttpResponse<T, 307, false>;
export type $HttpPermanentRedirect<T> = $HttpResponse<T, 308, false>;
export type $HttpBadRequest<T> = $HttpResponse<T, 400, false>;
export type $HttpUnauthorized<T> = $HttpResponse<T, 401, false>;
export type $HttpPaymentRequired<T> = $HttpResponse<T, 402, false>;
export type $HttpForbidden<T> = $HttpResponse<T, 403, false>;
export type $HttpNotFound<T> = $HttpResponse<T, 404, false>;
export type $HttpMethodNotAllowed<T> = $HttpResponse<T, 405, false>;
export type $HttpNotAcceptable<T> = $HttpResponse<T, 406, false>;
export type $HttpProxyAuthenticationRequired<T> = $HttpResponse<T, 407, false>;
export type $HttpRequestTimeout<T> = $HttpResponse<T, 408, false>;
export type $HttpConflict<T> = $HttpResponse<T, 409, false>;
export type $HttpGone<T> = $HttpResponse<T, 410, false>;
export type $HttpLengthRequired<T> = $HttpResponse<T, 411, false>;
export type $HttpPreconditionFailed<T> = $HttpResponse<T, 412, false>;
export type $HttpRequestEntityTooLarge<T> = $HttpResponse<T, 413, false>;
export type $HttpRequestUriTooLong<T> = $HttpResponse<T, 414, false>;
export type $HttpUnsupportedMediaType<T> = $HttpResponse<T, 415, false>;
export type $HttpRequestedRangeNotSatisfiable<T> = $HttpResponse<T, 416, false>;
export type $HttpExpectationFailed<T> = $HttpResponse<T, 417, false>;
export type $HttpMisdirectedRequest<T> = $HttpResponse<T, 421, false>;
export type $HttpUnprocessableEntity<T> = $HttpResponse<T, 422, false>;
export type $HttpLocked<T> = $HttpResponse<T, 423, false>;
export type $HttpFailedDependency<T> = $HttpResponse<T, 424, false>;
export type $HttpUpgradeRequired<T> = $HttpResponse<T, 426, false>;
export type $HttpPreconditionRequired<T> = $HttpResponse<T, 428, false>;
export type $HttpTooManyRequests<T> = $HttpResponse<T, 429, false>;
export type $HttpRequestHeaderFieldsTooLarge<T> = $HttpResponse<T, 431, false>;
export type $HttpNoResponse<T> = $HttpResponse<T, 444, false>;
export type $HttpRetryWith<T> = $HttpResponse<T, 449, false>;
export type $HttpBlockedByWindowsParentalControls<T> = $HttpResponse<T, 450, false>;
export type $HttpUnavailableForLegalReasons<T> = $HttpResponse<T, 451, false>;
export type $HttpClientClosedRequest<T> = $HttpResponse<T, 499, false>;
export type $HttpInternalServerError<T> = $HttpResponse<T, 500, false>;
export type $HttpNotImplemented<T> = $HttpResponse<T, 501, false>;
export type $HttpBadGateway<T> = $HttpResponse<T, 502, false>;
export type $HttpServiceUnavailable<T> = $HttpResponse<T, 503, false>;
export type $HttpGatewayTimeout<T> = $HttpResponse<T, 504, false>;
export type $HttpHttpVersionNotSupported<T> = $HttpResponse<T, 505, false>;
export type $HttpInsufficientStorage<T> = $HttpResponse<T, 507, false>;
export type $HttpLoopDetected<T> = $HttpResponse<T, 508, false>;
export type $HttpBandwidthLimitExceeded<T> = $HttpResponse<T, 509, false>;
export type $HttpNotExtended<T> = $HttpResponse<T, 510, false>;
export type $HttpNetworkAuthenticationRequired<T> = $HttpResponse<T, 511, false>;
export type $HttpNetworkReadTimeoutError<T> = $HttpResponse<T, 598, false>;
export type $HttpNetworkConnectTimeoutError<T> = $HttpResponse<T, 599, false>;

export interface $HttpClientOptions {
  fetch: $FetchFunction;
}

export function isResponseEmpty(response: Response): boolean {
  const contentLength = response.headers.get('Content-Length');
  return response.status === 204 || contentLength != null && Number.parseInt(contentLength, 10) === 0;
}

export function isResponseJson(response: Response): boolean {
  const contentType = response.headers.get('Content-Type');
  return contentType != null && contentType.indexOf('json') >= 0;
}

export function parseJson(response: Response): Promise<any> {
  return !isResponseEmpty(response) && isResponseJson(response) ? response.json() : Promise.resolve();
}

export function parseHeaders(response: Response): Record<string, string> {
  const headers: Record<string, string> = {};

  response.headers.forEach((value, key) => {
    headers[key.toLowerCase()] = value;
  });

  return headers;
}

export function stripQuery(query: $HttpQuery = {}): $HttpQuery {
  const initialValue: $HttpQuery = {};

  return Object.keys(query).reduce((previousValue, key) => {
    const value = query[key];

    if (value != null)
      previousValue[key] = value;

    return previousValue;
  }, initialValue);
}

export class $HttpClient {
  private options: $HttpClientOptions;

  constructor(options: $HttpClientOptions) {
    this.options = options;
  }

  public request(options: $HttpRequestOptions): Promise<$HttpResponse<any, any, any>> {
    const finalUrl: string = url.format({
      hostname: 'api.apibuilder.io',
      pathname: options.endpoint,
      protocol: 'https:',
      query: stripQuery(options.query),
    });

    const finalHeaders: $HttpHeaders = {
      accept: 'application/json',
      'content-type': 'application/json',
      ...options.headers,
    };

    const request: $HttpRequest = {
      body: options.body,
      headers: finalHeaders,
      method: options.method,
      url: finalUrl,
    };

    return this.options.fetch(request.url, {
      body: JSON.stringify(request.body),
      headers: request.headers,
      method: request.method,
    }).then((response) => {
      return parseJson(response).then((json) => {
        return {
          body: json,
          headers: parseHeaders(response),
          ok: response.ok,
          request,
          status: response.status,
          statusText: response.statusText,
        };
      });
    });
  }
}

export class $Resource {
  protected client: $HttpClient;

  constructor(options: $HttpClientOptions) {
    this.client = new $HttpClient(options);
  }
}

export interface AccountsPostCreateParameters {
  headers?: $HttpHeaders;
  accountid: number;
  ownerid: string;
  total_amount: number;
  sold: number;
  debit: number;
  currency: string;
}

export interface AccountsPutUpdateByAccountidParameters {
  headers?: $HttpHeaders;
  accountid: number;
  ownerid: string;
  total_amount: number;
  currency: string;
  sold: number;
  debit: number;
}

export interface AccountsDeleteDeleteByAccountidParameters {
  headers?: $HttpHeaders;
  accountid: number;
}

export interface AccountsGetByAccountidParameters {
  headers?: $HttpHeaders;
  accountid: number;
  ownerid: string;
  total_amount: number;
  sold: number;
  debit: number;
  currency: string;
}

export interface AccountsGetListParameters {
  headers?: $HttpHeaders;
  accountid: number;
  ownerid: string;
  total_amount: number;
  currency: string;
  sold: number;
  debit: number;
}

export interface DepositsDeleteDeleteByDepidParameters {
  headers?: $HttpHeaders;
  depid: number;
}

export interface DepositsGetByDepidParameters {
  headers?: $HttpHeaders;
  depid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface DepositsGetListParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface PaymentsPostCreateParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  currency: string;
  phone: number;
  pin: number;
  payment_context: string;
}

export interface PaymentsPutUpdateByPayidParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface PaymentsDeleteDeleteByPayidParameters {
  headers?: $HttpHeaders;
  payid: number;
}

export interface PaymentsGetByPayidParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface PaymentsGetByRefAccountidParameters {
  headers?: $HttpHeaders;
  ref_accountid: number;
  payid: number;
  payment_method: string;
  actorid: string;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface PaymentsGetListParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface TransfersPostCreateParameters {
  headers?: $HttpHeaders;
  transferid: number;
  senderid: string;
  amount: number;
  currency: string;
  ref_accountid_receiver: number;
  ref_accountid_sender: number;
}

export interface TransfersPutUpdateByTransferidParameters {
  headers?: $HttpHeaders;
  transferid: number;
  senderid: string;
  amount: number;
  currency: string;
  ref_accountid_receiver: number;
  ref_accountid_sender: number;
}

export interface TransfersDeleteDeleteByTransferidParameters {
  headers?: $HttpHeaders;
  transferid: number;
}

export interface TransfersGetByTransferidParameters {
  headers?: $HttpHeaders;
  transferid: number;
  senderid: string;
  amount: number;
  currency: string;
  ref_accountid_receiver: number;
  ref_accountid_sender: number;
}

export interface TransfersGetListParameters {
  headers?: $HttpHeaders;
  transferid: number;
  senderid: string;
  amount: number;
  currency: string;
  ref_accountid_receiver: number;
  ref_accountid_sender: number;
}

export interface ValidationsPostParameters {
  body: string;
  headers?: $HttpHeaders;
}

export interface WithdrawsDeleteDeleteByWdwidParameters {
  headers?: $HttpHeaders;
  wdwid: number;
}

export interface WithdrawsGetByWdwidParameters {
  headers?: $HttpHeaders;
  wdwid: number;
  depid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export interface WithdrawsGetListParameters {
  headers?: $HttpHeaders;
  payid: number;
  payment_method: string;
  actorid: string;
  ref_accountid: number;
  operatorid: string;
  amount: number;
  phone: number;
  pin: number;
  currency: string;
  payment_context: string;
}

export type AccountsPostCreateResponse = $HttpOk<payp.mard2p.api.v0.models.Account> | $HttpConflict<undefined>;
export type AccountsPutUpdateByAccountidResponse = $HttpOk<payp.mard2p.api.v0.models.Account> | $HttpConflict<undefined>;
export type AccountsDeleteDeleteByAccountidResponse = $HttpNoContent<undefined> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type AccountsGetByAccountidResponse = $HttpOk<payp.mard2p.api.v0.models.Account> | $HttpNotFound<undefined>;
export type AccountsGetListResponse = $HttpOk<payp.mard2p.api.v0.models.Account[]> | $HttpNotFound<undefined>;
export type DepositsDeleteDeleteByDepidResponse = $HttpNoContent<undefined> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type DepositsGetByDepidResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpNotFound<undefined>;
export type DepositsGetListResponse = $HttpOk<payp.mard2p.api.v0.models.Payment[]> | $HttpNotFound<undefined>;
export type PaymentsPostCreateResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpConflict<undefined>;
export type PaymentsPutUpdateByPayidResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpConflict<undefined>;
export type PaymentsDeleteDeleteByPayidResponse = $HttpNoContent<undefined> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type PaymentsGetByPayidResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpNotFound<undefined>;
export type PaymentsGetByRefAccountidResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpNotFound<undefined>;
export type PaymentsGetListResponse = $HttpOk<payp.mard2p.api.v0.models.Payment[]> | $HttpNotFound<undefined>;
export type TransfersPostCreateResponse = $HttpOk<payp.mard2p.api.v0.models.Transfer> | $HttpConflict<undefined>;
export type TransfersPutUpdateByTransferidResponse = $HttpOk<payp.mard2p.api.v0.models.Transfer> | $HttpConflict<undefined>;
export type TransfersDeleteDeleteByTransferidResponse = $HttpNoContent<undefined> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type TransfersGetByTransferidResponse = $HttpOk<payp.mard2p.api.v0.models.Account> | $HttpNotFound<undefined>;
export type TransfersGetListResponse = $HttpOk<payp.mard2p.api.v0.models.Account[]> | $HttpNotFound<undefined>;
export type ValidationsPostResponse = $HttpOk<payp.mard2p.api.v0.models.Validation>;
export type WithdrawsDeleteDeleteByWdwidResponse = $HttpNoContent<undefined> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type WithdrawsGetByWdwidResponse = $HttpOk<payp.mard2p.api.v0.models.Payment> | $HttpNotFound<undefined>;
export type WithdrawsGetListResponse = $HttpOk<payp.mard2p.api.v0.models.Payment[]> | $HttpNotFound<undefined>;

export class AccountsResource extends $Resource {
  /*Used to create an account.*/
  public postCreate(params: AccountsPostCreateParameters): Promise<AccountsPostCreateResponse> {
    return this.client.request({
      endpoint: '/accounts/create',
      headers: params.headers,
      method: 'POST',
    });
  }

  /*Used to update an account.*/
  public putUpdateByAccountid(params: AccountsPutUpdateByAccountidParameters): Promise<AccountsPutUpdateByAccountidResponse> {
    return this.client.request({
      endpoint: `/accounts/update/${encodeURIComponent(params.accountid)}`,
      headers: params.headers,
      method: 'PUT',
    });
  }

  /*Delete some account.*/
  public deleteDeleteByAccountid(params: AccountsDeleteDeleteByAccountidParameters): Promise<AccountsDeleteDeleteByAccountidResponse> {
    return this.client.request({
      endpoint: `/accounts/delete/${encodeURIComponent(params.accountid)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }

  /*Find account by its id*/
  public getByAccountid(params: AccountsGetByAccountidParameters): Promise<AccountsGetByAccountidResponse> {
    return this.client.request({
      endpoint: `/accounts/${encodeURIComponent(params.accountid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        currency: params.currency,
        debit: params.debit,
        ownerid: params.ownerid,
        sold: params.sold,
        total_amount: params.total_amount,
      },
    });
  }

  /*Find all the accounts.*/
  public getList(params: AccountsGetListParameters): Promise<AccountsGetListResponse> {
    return this.client.request({
      endpoint: '/accounts/list',
      headers: params.headers,
      method: 'GET',

      query: {
        accountid: params.accountid,
        currency: params.currency,
        debit: params.debit,
        ownerid: params.ownerid,
        sold: params.sold,
        total_amount: params.total_amount,
      },
    });
  }
}

export class DepositsResource extends $Resource {
  /*Delete some deposit.*/
  public deleteDeleteByDepid(params: DepositsDeleteDeleteByDepidParameters): Promise<DepositsDeleteDeleteByDepidResponse> {
    return this.client.request({
      endpoint: `/deposits/delete/${encodeURIComponent(params.depid)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }

  /*Find deposit by its id.*/
  public getByDepid(params: DepositsGetByDepidParameters): Promise<DepositsGetByDepidResponse> {
    return this.client.request({
      endpoint: `/deposits/${encodeURIComponent(params.depid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }

  /*List all the deposits*/
  public getList(params: DepositsGetListParameters): Promise<DepositsGetListResponse> {
    return this.client.request({
      endpoint: '/deposits/list',
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payid: params.payid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }
}

export class PaymentsResource extends $Resource {
  /*Used to create a payment.*/
  public postCreate(params: PaymentsPostCreateParameters): Promise<PaymentsPostCreateResponse> {
    return this.client.request({
      endpoint: '/payments/create',
      headers: params.headers,
      method: 'POST',
    });
  }

  /*Used to update a payment.*/
  public putUpdateByPayid(params: PaymentsPutUpdateByPayidParameters): Promise<PaymentsPutUpdateByPayidResponse> {
    return this.client.request({
      endpoint: `/payments/update/${encodeURIComponent(params.payid)}`,
      headers: params.headers,
      method: 'PUT',
    });
  }

  /*Delete some payment.*/
  public deleteDeleteByPayid(params: PaymentsDeleteDeleteByPayidParameters): Promise<PaymentsDeleteDeleteByPayidResponse> {
    return this.client.request({
      endpoint: `/payments/delete/${encodeURIComponent(params.payid)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }

  /*Find payment by its id.*/
  public getByPayid(params: PaymentsGetByPayidParameters): Promise<PaymentsGetByPayidResponse> {
    return this.client.request({
      endpoint: `/payments/${encodeURIComponent(params.payid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }

  /*Find payment by id accountid*/
  public getByRefAccountid(params: PaymentsGetByRefAccountidParameters): Promise<PaymentsGetByRefAccountidResponse> {
    return this.client.request({
      endpoint: `/payments/${encodeURIComponent(params.ref_accountid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payid: params.payid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
      },
    });
  }

  /*List all the payments*/
  public getList(params: PaymentsGetListParameters): Promise<PaymentsGetListResponse> {
    return this.client.request({
      endpoint: '/payments/list',
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payid: params.payid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }
}

export class TransfersResource extends $Resource {
  /*Used to create a transfer resource.*/
  public postCreate(params: TransfersPostCreateParameters): Promise<TransfersPostCreateResponse> {
    return this.client.request({
      endpoint: '/transfers/create',
      headers: params.headers,
      method: 'POST',
    });
  }

  /*Used to update a transfer resource.*/
  public putUpdateByTransferid(params: TransfersPutUpdateByTransferidParameters): Promise<TransfersPutUpdateByTransferidResponse> {
    return this.client.request({
      endpoint: `/transfers/update/${encodeURIComponent(params.transferid)}`,
      headers: params.headers,
      method: 'PUT',
    });
  }

  /*Delete some transfer.*/
  public deleteDeleteByTransferid(params: TransfersDeleteDeleteByTransferidParameters): Promise<TransfersDeleteDeleteByTransferidResponse> {
    return this.client.request({
      endpoint: `/transfers/delete/${encodeURIComponent(params.transferid)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }

  /*Find transfer by its id*/
  public getByTransferid(params: TransfersGetByTransferidParameters): Promise<TransfersGetByTransferidResponse> {
    return this.client.request({
      endpoint: `/transfers/${encodeURIComponent(params.transferid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        amount: params.amount,
        currency: params.currency,
        ref_accountid_receiver: params.ref_accountid_receiver,
        ref_accountid_sender: params.ref_accountid_sender,
        senderid: params.senderid,
      },
    });
  }

  /*Find all the transfers.*/
  public getList(params: TransfersGetListParameters): Promise<TransfersGetListResponse> {
    return this.client.request({
      endpoint: '/transfers/list',
      headers: params.headers,
      method: 'GET',

      query: {
        amount: params.amount,
        currency: params.currency,
        ref_accountid_receiver: params.ref_accountid_receiver,
        ref_accountid_sender: params.ref_accountid_sender,
        senderid: params.senderid,
        transferid: params.transferid,
      },
    });
  }
}

export class ValidationsResource extends $Resource {
  public post(params: ValidationsPostParameters): Promise<ValidationsPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: '/validations',
      headers: params.headers,
      method: 'POST',
    });
  }
}

export class WithdrawsResource extends $Resource {
  /*Delete some withdraw.*/
  public deleteDeleteByWdwid(params: WithdrawsDeleteDeleteByWdwidParameters): Promise<WithdrawsDeleteDeleteByWdwidResponse> {
    return this.client.request({
      endpoint: `/withdraws/delete/${encodeURIComponent(params.wdwid)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }

  /*Find withdraw by its id.*/
  public getByWdwid(params: WithdrawsGetByWdwidParameters): Promise<WithdrawsGetByWdwidResponse> {
    return this.client.request({
      endpoint: `/withdraws/${encodeURIComponent(params.wdwid)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        depid: params.depid,
        operatorid: params.operatorid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }

  /*List all the withdraws*/
  public getList(params: WithdrawsGetListParameters): Promise<WithdrawsGetListResponse> {
    return this.client.request({
      endpoint: '/withdraws/list',
      headers: params.headers,
      method: 'GET',

      query: {
        actorid: params.actorid,
        amount: params.amount,
        currency: params.currency,
        operatorid: params.operatorid,
        payid: params.payid,
        payment_context: params.payment_context,
        payment_method: params.payment_method,
        phone: params.phone,
        pin: params.pin,
        ref_accountid: params.ref_accountid,
      },
    });
  }
}

export interface ClientInstance {
  accounts: AccountsResource;
  deposits: DepositsResource;
  payments: PaymentsResource;
  transfers: TransfersResource;
  validations: ValidationsResource;
  withdraws: WithdrawsResource;
}

export function createClient(options: $HttpClientOptions): ClientInstance {
  return {
    accounts: new AccountsResource(options),
    deposits: new DepositsResource(options),
    payments: new PaymentsResource(options),
    transfers: new TransfersResource(options),
    validations: new ValidationsResource(options),
    withdraws: new WithdrawsResource(options),
  };
}