import * as url from 'url';

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.github.com',
      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 BlobsGetByShaParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  sha: string;
}

export interface BlobsPostParameters {
  body: io.flow.github.v0.models.BlobForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface CommitsGetByShaParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  sha: string;
}

export interface CommitsPostParameters {
  body: io.flow.github.v0.models.CommitForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface ContentsGetReadmeParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  ref?: string;
}

export interface ContentsGetContentsByPathParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  path: string;
  ref?: string;
}

export interface HooksGetParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface HooksGetByIdParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  id: number;
}

export interface HooksPostParameters {
  body: io.flow.github.v0.models.HookForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface HooksDeleteByIdParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  id: number;
}

export interface PullRequestsPostParameters {
  body: io.flow.github.v0.models.PullRequestForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface PullRequestsGetParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  page?: number;
}

export interface RefsGetParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface RefsGetByRefParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  ref: string;
}

export interface RefsPostParameters {
  body: io.flow.github.v0.models.RefForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface RefsPutByRefParameters {
  body: io.flow.github.v0.models.RefUpdateForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  ref: string;
}

export interface RepositoriesGetUserAndReposParameters {
  headers?: $HttpHeaders;
  page?: number;
  visibility?: io.flow.github.v0.enums.Visibility;
  affiliation?: string;
  type?: string;
  sort?: string;
  direction?: string;
}

export interface RepositoriesGetUsersAndReposByUsernameParameters {
  headers?: $HttpHeaders;
  username: string;
  page?: number;
  type?: string;
  sort?: string;
  direction?: string;
}

export interface RepositoriesGetOrgsAndReposByOrgParameters {
  headers?: $HttpHeaders;
  org: string;
  page?: number;
  type?: string;
  sort?: string;
  direction?: string;
}

export interface TagsGetTagsParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  page?: number;
  per_page?: number;
}

export interface TagsGetTagsByShaParameters {
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
  sha: string;
}

export interface TagsPostGitAndTagsParameters {
  body: io.flow.github.v0.models.TagForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface TreesPostParameters {
  body: io.flow.github.v0.models.CreateTreeForm;
  headers?: $HttpHeaders;
  owner: string;
  repo: string;
}

export interface UsersGetUserParameters {
  headers?: $HttpHeaders;
}

export interface UsersGetUserAndOrgsParameters {
  headers?: $HttpHeaders;
  page?: number;
  per_page?: number;
}

export interface UserEmailsGetParameters {
  headers?: $HttpHeaders;
}

export type BlobsGetByShaResponse = $HttpOk<io.flow.github.v0.models.Blob> | $HttpNotFound<undefined>;
export type BlobsPostResponse = $HttpCreated<io.flow.github.v0.models.BlobCreated> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type CommitsGetByShaResponse = $HttpOk<io.flow.github.v0.models.Commit> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type CommitsPostResponse = $HttpCreated<io.flow.github.v0.models.CommitResponse> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type ContentsGetReadmeResponse = $HttpOk<io.flow.github.v0.models.Contents> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type ContentsGetContentsByPathResponse = $HttpOk<io.flow.github.v0.models.Contents> | $HttpUnauthorized<undefined> | $HttpNotFound<undefined>;
export type HooksGetResponse = $HttpOk<io.flow.github.v0.models.Hook[]> | $HttpNotFound<undefined>;
export type HooksGetByIdResponse = $HttpOk<io.flow.github.v0.models.Hook> | $HttpNotFound<undefined>;
export type HooksPostResponse = $HttpCreated<io.flow.github.v0.models.Hook> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type HooksDeleteByIdResponse = $HttpNoContent<undefined> | $HttpNotFound<undefined>;
export type PullRequestsPostResponse = $HttpCreated<io.flow.github.v0.models.PullRequest> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type PullRequestsGetResponse = $HttpOk<io.flow.github.v0.models.PullRequest[]> | $HttpNotFound<undefined>;
export type RefsGetResponse = $HttpOk<io.flow.github.v0.models.Ref[]> | $HttpNotFound<undefined>;
export type RefsGetByRefResponse = $HttpOk<io.flow.github.v0.models.Ref> | $HttpNotFound<undefined>;
export type RefsPostResponse = $HttpCreated<io.flow.github.v0.models.Ref> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type RefsPutByRefResponse = $HttpCreated<io.flow.github.v0.models.Ref> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type RepositoriesGetUserAndReposResponse = $HttpOk<io.flow.github.v0.models.Repository[]> | $HttpUnauthorized<undefined>;
export type RepositoriesGetUsersAndReposByUsernameResponse = $HttpOk<io.flow.github.v0.models.Repository[]> | $HttpUnauthorized<undefined>;
export type RepositoriesGetOrgsAndReposByOrgResponse = $HttpOk<io.flow.github.v0.models.Repository[]> | $HttpUnauthorized<undefined>;
export type TagsGetTagsResponse = $HttpOk<io.flow.github.v0.models.TagSummary[]> | $HttpNotFound<undefined>;
export type TagsGetTagsByShaResponse = $HttpOk<io.flow.github.v0.models.Tag> | $HttpNotFound<undefined>;
export type TagsPostGitAndTagsResponse = $HttpCreated<io.flow.github.v0.models.Tag> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type TreesPostResponse = $HttpCreated<io.flow.github.v0.models.CreateTreeResponse> | $HttpNotFound<undefined> | $HttpUnprocessableEntity<io.flow.github.v0.models.UnprocessableEntity>;
export type UsersGetUserResponse = $HttpOk<io.flow.github.v0.models.User> | $HttpUnauthorized<undefined>;
export type UsersGetUserAndOrgsResponse = $HttpOk<io.flow.github.v0.models.UserOrg[]> | $HttpUnauthorized<undefined>;
export type UserEmailsGetResponse = $HttpOk<io.flow.github.v0.models.UserEmail[]> | $HttpUnauthorized<undefined>;

export class BlobsResource extends $Resource {
  public getBySha(params: BlobsGetByShaParameters): Promise<BlobsGetByShaResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/blobs/${encodeURIComponent(params.sha)}`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public post(params: BlobsPostParameters): Promise<BlobsPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/blobs`,
      headers: params.headers,
      method: 'POST',
    });
  }
}

export class CommitsResource extends $Resource {
  public getBySha(params: CommitsGetByShaParameters): Promise<CommitsGetByShaResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/commits/${encodeURIComponent(params.sha)}`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public post(params: CommitsPostParameters): Promise<CommitsPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/commits`,
      headers: params.headers,
      method: 'POST',
    });
  }
}

export class ContentsResource extends $Resource {
  public getReadme(params: ContentsGetReadmeParameters): Promise<ContentsGetReadmeResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/readme`,
      headers: params.headers,
      method: 'GET',

      query: {
        ref: params.ref,
      },
    });
  }

  public getContentsByPath(params: ContentsGetContentsByPathParameters): Promise<ContentsGetContentsByPathResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/contents/${encodeURIComponent(params.path)}`,
      headers: params.headers,
      method: 'GET',

      query: {
        ref: params.ref,
      },
    });
  }
}

export class HooksResource extends $Resource {
  public get(params: HooksGetParameters): Promise<HooksGetResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/hooks`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public getById(params: HooksGetByIdParameters): Promise<HooksGetByIdResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/hooks/${encodeURIComponent(params.id)}`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public post(params: HooksPostParameters): Promise<HooksPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/hooks`,
      headers: params.headers,
      method: 'POST',
    });
  }

  public deleteById(params: HooksDeleteByIdParameters): Promise<HooksDeleteByIdResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/hooks/${encodeURIComponent(params.id)}`,
      headers: params.headers,
      method: 'DELETE',
    });
  }
}

export class PullRequestsResource extends $Resource {
  public post(params: PullRequestsPostParameters): Promise<PullRequestsPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/pulls`,
      headers: params.headers,
      method: 'POST',
    });
  }

  public get(params: PullRequestsGetParameters): Promise<PullRequestsGetResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/pulls`,
      headers: params.headers,
      method: 'GET',

      query: {
        page: params.page,
      },
    });
  }
}

export class RefsResource extends $Resource {
  public get(params: RefsGetParameters): Promise<RefsGetResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/refs`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public getByRef(params: RefsGetByRefParameters): Promise<RefsGetByRefResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/refs/${encodeURIComponent(params.ref)}`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public post(params: RefsPostParameters): Promise<RefsPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/refs`,
      headers: params.headers,
      method: 'POST',
    });
  }

  public putByRef(params: RefsPutByRefParameters): Promise<RefsPutByRefResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/refs/${encodeURIComponent(params.ref)}`,
      headers: params.headers,
      method: 'PUT',
    });
  }
}

export class RepositoriesResource extends $Resource {
  public getUserAndRepos(params: RepositoriesGetUserAndReposParameters): Promise<RepositoriesGetUserAndReposResponse> {
    return this.client.request({
      endpoint: '/user/repos',
      headers: params.headers,
      method: 'GET',

      query: {
        affiliation: params.affiliation,
        direction: params.direction,
        page: params.page,
        sort: params.sort,
        type: params.type,
        visibility: params.visibility,
      },
    });
  }

  /*List public repositories for the specified user.*/
  public getUsersAndReposByUsername(params: RepositoriesGetUsersAndReposByUsernameParameters): Promise<RepositoriesGetUsersAndReposByUsernameResponse> {
    return this.client.request({
      endpoint: `/users/${encodeURIComponent(params.username)}/repos`,
      headers: params.headers,
      method: 'GET',

      query: {
        direction: params.direction,
        page: params.page,
        sort: params.sort,
        type: params.type,
      },
    });
  }

  /*List repositories for the specified org.*/
  public getOrgsAndReposByOrg(params: RepositoriesGetOrgsAndReposByOrgParameters): Promise<RepositoriesGetOrgsAndReposByOrgResponse> {
    return this.client.request({
      endpoint: `/orgs/${encodeURIComponent(params.org)}/repos`,
      headers: params.headers,
      method: 'GET',

      query: {
        direction: params.direction,
        page: params.page,
        sort: params.sort,
        type: params.type,
      },
    });
  }
}

export class TagsResource extends $Resource {
  public getTags(params: TagsGetTagsParameters): Promise<TagsGetTagsResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/tags`,
      headers: params.headers,
      method: 'GET',

      query: {
        page: params.page,
        per_page: params.per_page,
      },
    });
  }

  public getTagsBySha(params: TagsGetTagsByShaParameters): Promise<TagsGetTagsByShaResponse> {
    return this.client.request({
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/tags/${encodeURIComponent(params.sha)}`,
      headers: params.headers,
      method: 'GET',
    });
  }

  public postGitAndTags(params: TagsPostGitAndTagsParameters): Promise<TagsPostGitAndTagsResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/tags`,
      headers: params.headers,
      method: 'POST',
    });
  }
}

export class TreesResource extends $Resource {
  public post(params: TreesPostParameters): Promise<TreesPostResponse> {
    return this.client.request({
      body: params.body,
      endpoint: `/repos/${encodeURIComponent(params.owner)}/${encodeURIComponent(params.repo)}/git/trees`,
      headers: params.headers,
      method: 'POST',
    });
  }
}

export class UsersResource extends $Resource {
  public getUser(params: UsersGetUserParameters = {}): Promise<UsersGetUserResponse> {
    return this.client.request({
      endpoint: '/user',
      headers: params.headers,
      method: 'GET',
    });
  }

  public getUserAndOrgs(params: UsersGetUserAndOrgsParameters): Promise<UsersGetUserAndOrgsResponse> {
    return this.client.request({
      endpoint: '/user/orgs',
      headers: params.headers,
      method: 'GET',

      query: {
        page: params.page,
        per_page: params.per_page,
      },
    });
  }
}

export class UserEmailsResource extends $Resource {
  public get(params: UserEmailsGetParameters = {}): Promise<UserEmailsGetResponse> {
    return this.client.request({
      endpoint: '/user/emails',
      headers: params.headers,
      method: 'GET',
    });
  }
}

export interface ClientInstance {
  blobs: BlobsResource;
  commits: CommitsResource;
  contents: ContentsResource;
  hooks: HooksResource;
  pullRequests: PullRequestsResource;
  refs: RefsResource;
  repositories: RepositoriesResource;
  tags: TagsResource;
  trees: TreesResource;
  users: UsersResource;
  userEmails: UserEmailsResource;
}

export function createClient(options: $HttpClientOptions): ClientInstance {
  return {
    blobs: new BlobsResource(options),
    commits: new CommitsResource(options),
    contents: new ContentsResource(options),
    hooks: new HooksResource(options),
    pullRequests: new PullRequestsResource(options),
    refs: new RefsResource(options),
    repositories: new RepositoriesResource(options),
    tags: new TagsResource(options),
    trees: new TreesResource(options),
    users: new UsersResource(options),
    userEmails: new UserEmailsResource(options),
  };
}