/*
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

import * as msRest from "@azure/ms-rest-js";
import * as Models from "./models";
import * as Mappers from "./models/mappers";
import * as Parameters from "./models/parameters";
import { MetabaseApiContext } from "./metabaseApiContext";

class MetabaseApi extends MetabaseApiContext {
  /**
   * Initializes a new instance of the MetabaseApi class.
   * @param credentials Subscription credentials which uniquely identify client subscription.
   * @param [options] The parameter options
   */
  constructor(credentials: msRest.ServiceClientCredentials, options?: Models.MetabaseApiOptions) {
    super(credentials, options);
  }

  /**
   * @summary Set batch status for go between batch.
   * @param id
   * @param status
   * @param [options] The optional parameters
   * @returns Promise<Models.SetBatchStatusForGoBetweenBatchResponse>
   */
  setBatchStatusForGoBetweenBatch(id: string, status: Models.BatchStatusGoBetweenScope, options?: msRest.RequestOptionsBase): Promise<Models.SetBatchStatusForGoBetweenBatchResponse>;
  /**
   * @param id
   * @param status
   * @param callback The callback
   */
  setBatchStatusForGoBetweenBatch(id: string, status: Models.BatchStatusGoBetweenScope, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  /**
   * @param id
   * @param status
   * @param options The optional parameters
   * @param callback The callback
   */
  setBatchStatusForGoBetweenBatch(id: string, status: Models.BatchStatusGoBetweenScope, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  setBatchStatusForGoBetweenBatch(id: string, status: Models.BatchStatusGoBetweenScope, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<{ [propertyName: string]: string[] }>, callback?: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): Promise<Models.SetBatchStatusForGoBetweenBatchResponse> {
    return this.sendOperationRequest(
      {
        id,
        status,
        options
      },
      setBatchStatusForGoBetweenBatchOperationSpec,
      callback) as Promise<Models.SetBatchStatusForGoBetweenBatchResponse>;
  }

  /**
   * @summary Get paged statuses for batch.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetPagedStatusesForBatchResponse>
   */
  getPagedStatusesForBatch(id: string, options?: Models.MetabaseApiGetPagedStatusesForBatchOptionalParams): Promise<Models.GetPagedStatusesForBatchResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getPagedStatusesForBatch(id: string, callback: msRest.ServiceCallback<Models.PagedResultOfBatchStatus>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getPagedStatusesForBatch(id: string, options: Models.MetabaseApiGetPagedStatusesForBatchOptionalParams, callback: msRest.ServiceCallback<Models.PagedResultOfBatchStatus>): void;
  getPagedStatusesForBatch(id: string, options?: Models.MetabaseApiGetPagedStatusesForBatchOptionalParams | msRest.ServiceCallback<Models.PagedResultOfBatchStatus>, callback?: msRest.ServiceCallback<Models.PagedResultOfBatchStatus>): Promise<Models.GetPagedStatusesForBatchResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getPagedStatusesForBatchOperationSpec,
      callback) as Promise<Models.GetPagedStatusesForBatchResponse>;
  }

  /**
   * @summary Events placeholder for batch.
   * @param [options] The optional parameters
   * @returns Promise<Models.EventsPlaceholderForBatchResponse>
   */
  eventsPlaceholderForBatch(options?: msRest.RequestOptionsBase): Promise<Models.EventsPlaceholderForBatchResponse>;
  /**
   * @param callback The callback
   */
  eventsPlaceholderForBatch(callback: msRest.ServiceCallback<Models.DataflowEvent>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  eventsPlaceholderForBatch(options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.DataflowEvent>): void;
  eventsPlaceholderForBatch(options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.DataflowEvent>, callback?: msRest.ServiceCallback<Models.DataflowEvent>): Promise<Models.EventsPlaceholderForBatchResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      eventsPlaceholderForBatchOperationSpec,
      callback) as Promise<Models.EventsPlaceholderForBatchResponse>;
  }

  /**
   * @summary Get all batches.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllBatchesResponse>
   */
  getAllBatches(options?: Models.MetabaseApiGetAllBatchesOptionalParams): Promise<Models.GetAllBatchesResponse>;
  /**
   * @param callback The callback
   */
  getAllBatches(callback: msRest.ServiceCallback<Models.Batch[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllBatches(options: Models.MetabaseApiGetAllBatchesOptionalParams, callback: msRest.ServiceCallback<Models.Batch[]>): void;
  getAllBatches(options?: Models.MetabaseApiGetAllBatchesOptionalParams | msRest.ServiceCallback<Models.Batch[]>, callback?: msRest.ServiceCallback<Models.Batch[]>): Promise<Models.GetAllBatchesResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllBatchesOperationSpec,
      callback) as Promise<Models.GetAllBatchesResponse>;
  }

  /**
   * @summary Create batch.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateBatchResponse>
   */
  createBatch(input: Models.Batch, options?: msRest.RequestOptionsBase): Promise<Models.CreateBatchResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createBatch(input: Models.Batch, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createBatch(input: Models.Batch, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createBatch(input: Models.Batch, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateBatchResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createBatchOperationSpec,
      callback) as Promise<Models.CreateBatchResponse>;
  }

  /**
   * @summary Get one batch.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneBatchResponse>
   */
  getOneBatch(id: string, options?: Models.MetabaseApiGetOneBatchOptionalParams): Promise<Models.GetOneBatchResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneBatch(id: string, callback: msRest.ServiceCallback<Models.Batch>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneBatch(id: string, options: Models.MetabaseApiGetOneBatchOptionalParams, callback: msRest.ServiceCallback<Models.Batch>): void;
  getOneBatch(id: string, options?: Models.MetabaseApiGetOneBatchOptionalParams | msRest.ServiceCallback<Models.Batch>, callback?: msRest.ServiceCallback<Models.Batch>): Promise<Models.GetOneBatchResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneBatchOperationSpec,
      callback) as Promise<Models.GetOneBatchResponse>;
  }

  /**
   * @summary Update batch.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateBatchResponse>
   */
  updateBatch(id: string, model: Models.Batch, options?: msRest.RequestOptionsBase): Promise<Models.UpdateBatchResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateBatch(id: string, model: Models.Batch, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateBatch(id: string, model: Models.Batch, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateBatch(id: string, model: Models.Batch, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateBatchResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateBatchOperationSpec,
      callback) as Promise<Models.UpdateBatchResponse>;
  }

  /**
   * @summary Delete batch.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteBatch(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteBatch(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteBatch(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteBatch(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteBatchOperationSpec,
      callback);
  }

  /**
   * @summary Get batch versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetBatchVersionsResponse>
   */
  getBatchVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetBatchVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getBatchVersions(id: string, callback: msRest.ServiceCallback<Models.Batch[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getBatchVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Batch[]>): void;
  getBatchVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Batch[]>, callback?: msRest.ServiceCallback<Models.Batch[]>): Promise<Models.GetBatchVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getBatchVersionsOperationSpec,
      callback) as Promise<Models.GetBatchVersionsResponse>;
  }

  /**
   * @summary Get all connections.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllConnectionsResponse>
   */
  getAllConnections(options?: Models.MetabaseApiGetAllConnectionsOptionalParams): Promise<Models.GetAllConnectionsResponse>;
  /**
   * @param callback The callback
   */
  getAllConnections(callback: msRest.ServiceCallback<Models.Connection[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllConnections(options: Models.MetabaseApiGetAllConnectionsOptionalParams, callback: msRest.ServiceCallback<Models.Connection[]>): void;
  getAllConnections(options?: Models.MetabaseApiGetAllConnectionsOptionalParams | msRest.ServiceCallback<Models.Connection[]>, callback?: msRest.ServiceCallback<Models.Connection[]>): Promise<Models.GetAllConnectionsResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllConnectionsOperationSpec,
      callback) as Promise<Models.GetAllConnectionsResponse>;
  }

  /**
   * @summary Create connection.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateConnectionResponse>
   */
  createConnection(input: Models.Connection, options?: msRest.RequestOptionsBase): Promise<Models.CreateConnectionResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createConnection(input: Models.Connection, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createConnection(input: Models.Connection, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createConnection(input: Models.Connection, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateConnectionResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createConnectionOperationSpec,
      callback) as Promise<Models.CreateConnectionResponse>;
  }

  /**
   * @summary Get one connection.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneConnectionResponse>
   */
  getOneConnection(id: string, options?: Models.MetabaseApiGetOneConnectionOptionalParams): Promise<Models.GetOneConnectionResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneConnection(id: string, callback: msRest.ServiceCallback<Models.Connection>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneConnection(id: string, options: Models.MetabaseApiGetOneConnectionOptionalParams, callback: msRest.ServiceCallback<Models.Connection>): void;
  getOneConnection(id: string, options?: Models.MetabaseApiGetOneConnectionOptionalParams | msRest.ServiceCallback<Models.Connection>, callback?: msRest.ServiceCallback<Models.Connection>): Promise<Models.GetOneConnectionResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneConnectionOperationSpec,
      callback) as Promise<Models.GetOneConnectionResponse>;
  }

  /**
   * @summary Update connection.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateConnectionResponse>
   */
  updateConnection(id: string, model: Models.Connection, options?: msRest.RequestOptionsBase): Promise<Models.UpdateConnectionResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateConnection(id: string, model: Models.Connection, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateConnection(id: string, model: Models.Connection, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateConnection(id: string, model: Models.Connection, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateConnectionResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateConnectionOperationSpec,
      callback) as Promise<Models.UpdateConnectionResponse>;
  }

  /**
   * @summary Delete connection.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteConnection(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteConnection(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteConnection(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteConnection(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteConnectionOperationSpec,
      callback);
  }

  /**
   * @summary Get connection versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetConnectionVersionsResponse>
   */
  getConnectionVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetConnectionVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getConnectionVersions(id: string, callback: msRest.ServiceCallback<Models.Connection[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getConnectionVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Connection[]>): void;
  getConnectionVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Connection[]>, callback?: msRest.ServiceCallback<Models.Connection[]>): Promise<Models.GetConnectionVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getConnectionVersionsOperationSpec,
      callback) as Promise<Models.GetConnectionVersionsResponse>;
  }

  /**
   * @summary Get all flows.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllFlowsResponse>
   */
  getAllFlows(options?: Models.MetabaseApiGetAllFlowsOptionalParams): Promise<Models.GetAllFlowsResponse>;
  /**
   * @param callback The callback
   */
  getAllFlows(callback: msRest.ServiceCallback<Models.Flow[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllFlows(options: Models.MetabaseApiGetAllFlowsOptionalParams, callback: msRest.ServiceCallback<Models.Flow[]>): void;
  getAllFlows(options?: Models.MetabaseApiGetAllFlowsOptionalParams | msRest.ServiceCallback<Models.Flow[]>, callback?: msRest.ServiceCallback<Models.Flow[]>): Promise<Models.GetAllFlowsResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllFlowsOperationSpec,
      callback) as Promise<Models.GetAllFlowsResponse>;
  }

  /**
   * @summary Create flow.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateFlowResponse>
   */
  createFlow(input: Models.Flow, options?: msRest.RequestOptionsBase): Promise<Models.CreateFlowResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createFlow(input: Models.Flow, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createFlow(input: Models.Flow, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createFlow(input: Models.Flow, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateFlowResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createFlowOperationSpec,
      callback) as Promise<Models.CreateFlowResponse>;
  }

  /**
   * @summary Get one flow.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneFlowResponse>
   */
  getOneFlow(id: string, options?: Models.MetabaseApiGetOneFlowOptionalParams): Promise<Models.GetOneFlowResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneFlow(id: string, callback: msRest.ServiceCallback<Models.Flow>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneFlow(id: string, options: Models.MetabaseApiGetOneFlowOptionalParams, callback: msRest.ServiceCallback<Models.Flow>): void;
  getOneFlow(id: string, options?: Models.MetabaseApiGetOneFlowOptionalParams | msRest.ServiceCallback<Models.Flow>, callback?: msRest.ServiceCallback<Models.Flow>): Promise<Models.GetOneFlowResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneFlowOperationSpec,
      callback) as Promise<Models.GetOneFlowResponse>;
  }

  /**
   * @summary Update flow.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateFlowResponse>
   */
  updateFlow(id: string, model: Models.Flow, options?: msRest.RequestOptionsBase): Promise<Models.UpdateFlowResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateFlow(id: string, model: Models.Flow, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateFlow(id: string, model: Models.Flow, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateFlow(id: string, model: Models.Flow, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateFlowResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateFlowOperationSpec,
      callback) as Promise<Models.UpdateFlowResponse>;
  }

  /**
   * @summary Delete flow.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteFlow(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteFlow(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteFlow(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteFlow(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteFlowOperationSpec,
      callback);
  }

  /**
   * @summary Get flow versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetFlowVersionsResponse>
   */
  getFlowVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetFlowVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getFlowVersions(id: string, callback: msRest.ServiceCallback<Models.Flow[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getFlowVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Flow[]>): void;
  getFlowVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Flow[]>, callback?: msRest.ServiceCallback<Models.Flow[]>): Promise<Models.GetFlowVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getFlowVersionsOperationSpec,
      callback) as Promise<Models.GetFlowVersionsResponse>;
  }

  /**
   * @summary Get job mapping.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetJobMappingResponse>
   */
  getJobMapping(id: string, options?: Models.MetabaseApiGetJobMappingOptionalParams): Promise<Models.GetJobMappingResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getJobMapping(id: string, callback: msRest.ServiceCallback<Models.Mapping>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getJobMapping(id: string, options: Models.MetabaseApiGetJobMappingOptionalParams, callback: msRest.ServiceCallback<Models.Mapping>): void;
  getJobMapping(id: string, options?: Models.MetabaseApiGetJobMappingOptionalParams | msRest.ServiceCallback<Models.Mapping>, callback?: msRest.ServiceCallback<Models.Mapping>): Promise<Models.GetJobMappingResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getJobMappingOperationSpec,
      callback) as Promise<Models.GetJobMappingResponse>;
  }

  /**
   * @summary Set job status for go between.
   * @param id
   * @param status
   * @param [options] The optional parameters
   * @returns Promise<Models.SetJobStatusForGoBetweenResponse>
   */
  setJobStatusForGoBetween(id: string, status: Models.JobStatusGoBetweenScope, options?: msRest.RequestOptionsBase): Promise<Models.SetJobStatusForGoBetweenResponse>;
  /**
   * @param id
   * @param status
   * @param callback The callback
   */
  setJobStatusForGoBetween(id: string, status: Models.JobStatusGoBetweenScope, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  /**
   * @param id
   * @param status
   * @param options The optional parameters
   * @param callback The callback
   */
  setJobStatusForGoBetween(id: string, status: Models.JobStatusGoBetweenScope, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  setJobStatusForGoBetween(id: string, status: Models.JobStatusGoBetweenScope, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<{ [propertyName: string]: string[] }>, callback?: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): Promise<Models.SetJobStatusForGoBetweenResponse> {
    return this.sendOperationRequest(
      {
        id,
        status,
        options
      },
      setJobStatusForGoBetweenOperationSpec,
      callback) as Promise<Models.SetJobStatusForGoBetweenResponse>;
  }

  /**
   * @summary Set real time state.
   * @param id
   * @param state
   * @param [options] The optional parameters
   * @returns Promise<Models.SetRealTimeStateResponse>
   */
  setRealTimeState(id: string, state: Models.RealTimeStateScope, options?: msRest.RequestOptionsBase): Promise<Models.SetRealTimeStateResponse>;
  /**
   * @param id
   * @param state
   * @param callback The callback
   */
  setRealTimeState(id: string, state: Models.RealTimeStateScope, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  /**
   * @param id
   * @param state
   * @param options The optional parameters
   * @param callback The callback
   */
  setRealTimeState(id: string, state: Models.RealTimeStateScope, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): void;
  setRealTimeState(id: string, state: Models.RealTimeStateScope, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<{ [propertyName: string]: string[] }>, callback?: msRest.ServiceCallback<{ [propertyName: string]: string[] }>): Promise<Models.SetRealTimeStateResponse> {
    return this.sendOperationRequest(
      {
        id,
        state,
        options
      },
      setRealTimeStateOperationSpec,
      callback) as Promise<Models.SetRealTimeStateResponse>;
  }

  /**
   * @summary Get all jobs.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllJobsResponse>
   */
  getAllJobs(options?: Models.MetabaseApiGetAllJobsOptionalParams): Promise<Models.GetAllJobsResponse>;
  /**
   * @param callback The callback
   */
  getAllJobs(callback: msRest.ServiceCallback<Models.Job[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllJobs(options: Models.MetabaseApiGetAllJobsOptionalParams, callback: msRest.ServiceCallback<Models.Job[]>): void;
  getAllJobs(options?: Models.MetabaseApiGetAllJobsOptionalParams | msRest.ServiceCallback<Models.Job[]>, callback?: msRest.ServiceCallback<Models.Job[]>): Promise<Models.GetAllJobsResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllJobsOperationSpec,
      callback) as Promise<Models.GetAllJobsResponse>;
  }

  /**
   * @summary Create job.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateJobResponse>
   */
  createJob(input: Models.Job, options?: msRest.RequestOptionsBase): Promise<Models.CreateJobResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createJob(input: Models.Job, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createJob(input: Models.Job, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createJob(input: Models.Job, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateJobResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createJobOperationSpec,
      callback) as Promise<Models.CreateJobResponse>;
  }

  /**
   * @summary Get paged statuses for job.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetPagedStatusesForJobResponse>
   */
  getPagedStatusesForJob(id: string, options?: Models.MetabaseApiGetPagedStatusesForJobOptionalParams): Promise<Models.GetPagedStatusesForJobResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getPagedStatusesForJob(id: string, callback: msRest.ServiceCallback<Models.PagedResultOfJobStatus>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getPagedStatusesForJob(id: string, options: Models.MetabaseApiGetPagedStatusesForJobOptionalParams, callback: msRest.ServiceCallback<Models.PagedResultOfJobStatus>): void;
  getPagedStatusesForJob(id: string, options?: Models.MetabaseApiGetPagedStatusesForJobOptionalParams | msRest.ServiceCallback<Models.PagedResultOfJobStatus>, callback?: msRest.ServiceCallback<Models.PagedResultOfJobStatus>): Promise<Models.GetPagedStatusesForJobResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getPagedStatusesForJobOperationSpec,
      callback) as Promise<Models.GetPagedStatusesForJobResponse>;
  }

  /**
   * @summary Events placeholder for job.
   * @param [options] The optional parameters
   * @returns Promise<Models.EventsPlaceholderForJobResponse>
   */
  eventsPlaceholderForJob(options?: msRest.RequestOptionsBase): Promise<Models.EventsPlaceholderForJobResponse>;
  /**
   * @param callback The callback
   */
  eventsPlaceholderForJob(callback: msRest.ServiceCallback<Models.DataflowEvent>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  eventsPlaceholderForJob(options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.DataflowEvent>): void;
  eventsPlaceholderForJob(options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.DataflowEvent>, callback?: msRest.ServiceCallback<Models.DataflowEvent>): Promise<Models.EventsPlaceholderForJobResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      eventsPlaceholderForJobOperationSpec,
      callback) as Promise<Models.EventsPlaceholderForJobResponse>;
  }

  /**
   * @summary Get one job.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneJobResponse>
   */
  getOneJob(id: string, options?: Models.MetabaseApiGetOneJobOptionalParams): Promise<Models.GetOneJobResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneJob(id: string, callback: msRest.ServiceCallback<Models.Job>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneJob(id: string, options: Models.MetabaseApiGetOneJobOptionalParams, callback: msRest.ServiceCallback<Models.Job>): void;
  getOneJob(id: string, options?: Models.MetabaseApiGetOneJobOptionalParams | msRest.ServiceCallback<Models.Job>, callback?: msRest.ServiceCallback<Models.Job>): Promise<Models.GetOneJobResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneJobOperationSpec,
      callback) as Promise<Models.GetOneJobResponse>;
  }

  /**
   * @summary Update job.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateJobResponse>
   */
  updateJob(id: string, model: Models.Job, options?: msRest.RequestOptionsBase): Promise<Models.UpdateJobResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateJob(id: string, model: Models.Job, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateJob(id: string, model: Models.Job, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateJob(id: string, model: Models.Job, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateJobResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateJobOperationSpec,
      callback) as Promise<Models.UpdateJobResponse>;
  }

  /**
   * @summary Delete job.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteJob(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteJob(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteJob(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteJob(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteJobOperationSpec,
      callback);
  }

  /**
   * @summary Get job versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetJobVersionsResponse>
   */
  getJobVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetJobVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getJobVersions(id: string, callback: msRest.ServiceCallback<Models.Job[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getJobVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Job[]>): void;
  getJobVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Job[]>, callback?: msRest.ServiceCallback<Models.Job[]>): Promise<Models.GetJobVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getJobVersionsOperationSpec,
      callback) as Promise<Models.GetJobVersionsResponse>;
  }

  /**
   * @summary Get all schema profiles.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllSchemaProfilesResponse>
   */
  getAllSchemaProfiles(options?: Models.MetabaseApiGetAllSchemaProfilesOptionalParams): Promise<Models.GetAllSchemaProfilesResponse>;
  /**
   * @param callback The callback
   */
  getAllSchemaProfiles(callback: msRest.ServiceCallback<Models.SchemaProfile[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllSchemaProfiles(options: Models.MetabaseApiGetAllSchemaProfilesOptionalParams, callback: msRest.ServiceCallback<Models.SchemaProfile[]>): void;
  getAllSchemaProfiles(options?: Models.MetabaseApiGetAllSchemaProfilesOptionalParams | msRest.ServiceCallback<Models.SchemaProfile[]>, callback?: msRest.ServiceCallback<Models.SchemaProfile[]>): Promise<Models.GetAllSchemaProfilesResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllSchemaProfilesOperationSpec,
      callback) as Promise<Models.GetAllSchemaProfilesResponse>;
  }

  /**
   * @summary Create schema profile.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateSchemaProfileResponse>
   */
  createSchemaProfile(input: Models.SchemaProfile, options?: msRest.RequestOptionsBase): Promise<Models.CreateSchemaProfileResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createSchemaProfile(input: Models.SchemaProfile, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createSchemaProfile(input: Models.SchemaProfile, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createSchemaProfile(input: Models.SchemaProfile, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateSchemaProfileResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createSchemaProfileOperationSpec,
      callback) as Promise<Models.CreateSchemaProfileResponse>;
  }

  /**
   * @summary Get one schema profile.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneSchemaProfileResponse>
   */
  getOneSchemaProfile(id: string, options?: Models.MetabaseApiGetOneSchemaProfileOptionalParams): Promise<Models.GetOneSchemaProfileResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneSchemaProfile(id: string, callback: msRest.ServiceCallback<Models.SchemaProfile>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneSchemaProfile(id: string, options: Models.MetabaseApiGetOneSchemaProfileOptionalParams, callback: msRest.ServiceCallback<Models.SchemaProfile>): void;
  getOneSchemaProfile(id: string, options?: Models.MetabaseApiGetOneSchemaProfileOptionalParams | msRest.ServiceCallback<Models.SchemaProfile>, callback?: msRest.ServiceCallback<Models.SchemaProfile>): Promise<Models.GetOneSchemaProfileResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneSchemaProfileOperationSpec,
      callback) as Promise<Models.GetOneSchemaProfileResponse>;
  }

  /**
   * @summary Update schema profile.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateSchemaProfileResponse>
   */
  updateSchemaProfile(id: string, model: Models.SchemaProfile, options?: msRest.RequestOptionsBase): Promise<Models.UpdateSchemaProfileResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateSchemaProfile(id: string, model: Models.SchemaProfile, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateSchemaProfile(id: string, model: Models.SchemaProfile, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateSchemaProfile(id: string, model: Models.SchemaProfile, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateSchemaProfileResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateSchemaProfileOperationSpec,
      callback) as Promise<Models.UpdateSchemaProfileResponse>;
  }

  /**
   * @summary Delete schema profile.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteSchemaProfile(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteSchemaProfile(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteSchemaProfile(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteSchemaProfile(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteSchemaProfileOperationSpec,
      callback);
  }

  /**
   * @summary Get schema profile versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetSchemaProfileVersionsResponse>
   */
  getSchemaProfileVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetSchemaProfileVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getSchemaProfileVersions(id: string, callback: msRest.ServiceCallback<Models.SchemaProfile[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getSchemaProfileVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.SchemaProfile[]>): void;
  getSchemaProfileVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.SchemaProfile[]>, callback?: msRest.ServiceCallback<Models.SchemaProfile[]>): Promise<Models.GetSchemaProfileVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getSchemaProfileVersionsOperationSpec,
      callback) as Promise<Models.GetSchemaProfileVersionsResponse>;
  }

  /**
   * @summary Get all schemas.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllSchemasResponse>
   */
  getAllSchemas(options?: Models.MetabaseApiGetAllSchemasOptionalParams): Promise<Models.GetAllSchemasResponse>;
  /**
   * @param callback The callback
   */
  getAllSchemas(callback: msRest.ServiceCallback<Models.Schema[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllSchemas(options: Models.MetabaseApiGetAllSchemasOptionalParams, callback: msRest.ServiceCallback<Models.Schema[]>): void;
  getAllSchemas(options?: Models.MetabaseApiGetAllSchemasOptionalParams | msRest.ServiceCallback<Models.Schema[]>, callback?: msRest.ServiceCallback<Models.Schema[]>): Promise<Models.GetAllSchemasResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllSchemasOperationSpec,
      callback) as Promise<Models.GetAllSchemasResponse>;
  }

  /**
   * @summary Create schema.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateSchemaResponse>
   */
  createSchema(input: Models.Schema, options?: msRest.RequestOptionsBase): Promise<Models.CreateSchemaResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createSchema(input: Models.Schema, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createSchema(input: Models.Schema, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createSchema(input: Models.Schema, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateSchemaResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createSchemaOperationSpec,
      callback) as Promise<Models.CreateSchemaResponse>;
  }

  /**
   * @summary Get one schema.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneSchemaResponse>
   */
  getOneSchema(id: string, options?: Models.MetabaseApiGetOneSchemaOptionalParams): Promise<Models.GetOneSchemaResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneSchema(id: string, callback: msRest.ServiceCallback<Models.Schema>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneSchema(id: string, options: Models.MetabaseApiGetOneSchemaOptionalParams, callback: msRest.ServiceCallback<Models.Schema>): void;
  getOneSchema(id: string, options?: Models.MetabaseApiGetOneSchemaOptionalParams | msRest.ServiceCallback<Models.Schema>, callback?: msRest.ServiceCallback<Models.Schema>): Promise<Models.GetOneSchemaResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneSchemaOperationSpec,
      callback) as Promise<Models.GetOneSchemaResponse>;
  }

  /**
   * @summary Update schema.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateSchemaResponse>
   */
  updateSchema(id: string, model: Models.Schema, options?: msRest.RequestOptionsBase): Promise<Models.UpdateSchemaResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateSchema(id: string, model: Models.Schema, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateSchema(id: string, model: Models.Schema, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateSchema(id: string, model: Models.Schema, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateSchemaResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateSchemaOperationSpec,
      callback) as Promise<Models.UpdateSchemaResponse>;
  }

  /**
   * @summary Delete schema.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteSchema(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteSchema(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteSchema(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteSchema(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteSchemaOperationSpec,
      callback);
  }

  /**
   * @summary Get schema versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetSchemaVersionsResponse>
   */
  getSchemaVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetSchemaVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getSchemaVersions(id: string, callback: msRest.ServiceCallback<Models.Schema[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getSchemaVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Schema[]>): void;
  getSchemaVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Schema[]>, callback?: msRest.ServiceCallback<Models.Schema[]>): Promise<Models.GetSchemaVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getSchemaVersionsOperationSpec,
      callback) as Promise<Models.GetSchemaVersionsResponse>;
  }

  /**
   * @summary Get all shapes.
   * @param [options] The optional parameters
   * @returns Promise<Models.GetAllShapesResponse>
   */
  getAllShapes(options?: Models.MetabaseApiGetAllShapesOptionalParams): Promise<Models.GetAllShapesResponse>;
  /**
   * @param callback The callback
   */
  getAllShapes(callback: msRest.ServiceCallback<Models.Shape[]>): void;
  /**
   * @param options The optional parameters
   * @param callback The callback
   */
  getAllShapes(options: Models.MetabaseApiGetAllShapesOptionalParams, callback: msRest.ServiceCallback<Models.Shape[]>): void;
  getAllShapes(options?: Models.MetabaseApiGetAllShapesOptionalParams | msRest.ServiceCallback<Models.Shape[]>, callback?: msRest.ServiceCallback<Models.Shape[]>): Promise<Models.GetAllShapesResponse> {
    return this.sendOperationRequest(
      {
        options
      },
      getAllShapesOperationSpec,
      callback) as Promise<Models.GetAllShapesResponse>;
  }

  /**
   * @summary Create shape.
   * @param input
   * @param [options] The optional parameters
   * @returns Promise<Models.CreateShapeResponse>
   */
  createShape(input: Models.Shape, options?: msRest.RequestOptionsBase): Promise<Models.CreateShapeResponse>;
  /**
   * @param input
   * @param callback The callback
   */
  createShape(input: Models.Shape, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param input
   * @param options The optional parameters
   * @param callback The callback
   */
  createShape(input: Models.Shape, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  createShape(input: Models.Shape, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.CreateShapeResponse> {
    return this.sendOperationRequest(
      {
        input,
        options
      },
      createShapeOperationSpec,
      callback) as Promise<Models.CreateShapeResponse>;
  }

  /**
   * @summary Get one shape.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetOneShapeResponse>
   */
  getOneShape(id: string, options?: Models.MetabaseApiGetOneShapeOptionalParams): Promise<Models.GetOneShapeResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getOneShape(id: string, callback: msRest.ServiceCallback<Models.Shape>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getOneShape(id: string, options: Models.MetabaseApiGetOneShapeOptionalParams, callback: msRest.ServiceCallback<Models.Shape>): void;
  getOneShape(id: string, options?: Models.MetabaseApiGetOneShapeOptionalParams | msRest.ServiceCallback<Models.Shape>, callback?: msRest.ServiceCallback<Models.Shape>): Promise<Models.GetOneShapeResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getOneShapeOperationSpec,
      callback) as Promise<Models.GetOneShapeResponse>;
  }

  /**
   * @summary Update shape.
   * @param id
   * @param model
   * @param [options] The optional parameters
   * @returns Promise<Models.UpdateShapeResponse>
   */
  updateShape(id: string, model: Models.Shape, options?: msRest.RequestOptionsBase): Promise<Models.UpdateShapeResponse>;
  /**
   * @param id
   * @param model
   * @param callback The callback
   */
  updateShape(id: string, model: Models.Shape, callback: msRest.ServiceCallback<any>): void;
  /**
   * @param id
   * @param model
   * @param options The optional parameters
   * @param callback The callback
   */
  updateShape(id: string, model: Models.Shape, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<any>): void;
  updateShape(id: string, model: Models.Shape, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<any>, callback?: msRest.ServiceCallback<any>): Promise<Models.UpdateShapeResponse> {
    return this.sendOperationRequest(
      {
        id,
        model,
        options
      },
      updateShapeOperationSpec,
      callback) as Promise<Models.UpdateShapeResponse>;
  }

  /**
   * @summary Delete shape.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<msRest.RestResponse>
   */
  deleteShape(id: string, options?: msRest.RequestOptionsBase): Promise<msRest.RestResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  deleteShape(id: string, callback: msRest.ServiceCallback<void>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  deleteShape(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<void>): void;
  deleteShape(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<void>, callback?: msRest.ServiceCallback<void>): Promise<msRest.RestResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      deleteShapeOperationSpec,
      callback);
  }

  /**
   * @summary Get shape versions.
   * @param id
   * @param [options] The optional parameters
   * @returns Promise<Models.GetShapeVersionsResponse>
   */
  getShapeVersions(id: string, options?: msRest.RequestOptionsBase): Promise<Models.GetShapeVersionsResponse>;
  /**
   * @param id
   * @param callback The callback
   */
  getShapeVersions(id: string, callback: msRest.ServiceCallback<Models.Shape[]>): void;
  /**
   * @param id
   * @param options The optional parameters
   * @param callback The callback
   */
  getShapeVersions(id: string, options: msRest.RequestOptionsBase, callback: msRest.ServiceCallback<Models.Shape[]>): void;
  getShapeVersions(id: string, options?: msRest.RequestOptionsBase | msRest.ServiceCallback<Models.Shape[]>, callback?: msRest.ServiceCallback<Models.Shape[]>): Promise<Models.GetShapeVersionsResponse> {
    return this.sendOperationRequest(
      {
        id,
        options
      },
      getShapeVersionsOperationSpec,
      callback) as Promise<Models.GetShapeVersionsResponse>;
  }
}

// Operation Specifications
const serializer = new msRest.Serializer(Mappers);
const setBatchStatusForGoBetweenBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/batches/{id}/status/go-between-agent",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "status",
    mapper: {
      ...Mappers.BatchStatusGoBetweenScope,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {},
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getPagedStatusesForBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/batches/{id}/status",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.page,
    Parameters.pageSize
  ],
  responses: {
    200: {
      bodyMapper: Mappers.PagedResultOfBatchStatus
    },
    default: {}
  },
  serializer
};

const eventsPlaceholderForBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/batches/events",
  responses: {
    200: {
      bodyMapper: Mappers.DataflowEvent
    },
    default: {}
  },
  serializer
};

const getAllBatchesOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/batches",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.jobId,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Batch"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/batches",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Batch,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Batch
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/batches/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Batch
    },
    default: {}
  },
  serializer
};

const updateBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/batches/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Batch,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Batch
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Batch
    },
    default: {}
  },
  serializer
};

const deleteBatchOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/batches/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getBatchVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/batches/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Batch"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllConnectionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/connections",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.plugin,
    Parameters.preferredAgent,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Connection"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createConnectionOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/connections",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Connection,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Connection
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneConnectionOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/connections/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Connection
    },
    default: {}
  },
  serializer
};

const updateConnectionOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/connections/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Connection,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Connection
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Connection
    },
    default: {}
  },
  serializer
};

const deleteConnectionOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/connections/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getConnectionVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/connections/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Connection"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllFlowsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/flows",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Flow"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createFlowOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/flows",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Flow,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Flow
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneFlowOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/flows/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Flow
    },
    default: {}
  },
  serializer
};

const updateFlowOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/flows/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Flow,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Flow
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Flow
    },
    default: {}
  },
  serializer
};

const deleteFlowOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/flows/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getFlowVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/flows/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Flow"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getJobMappingOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs/{id}/mapping",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Mapping
    },
    default: {}
  },
  serializer
};

const setJobStatusForGoBetweenOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/jobs/{id}/status/go-between",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "status",
    mapper: {
      ...Mappers.JobStatusGoBetweenScope,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {},
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const setRealTimeStateOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/jobs/{id}/status/realtime",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "state",
    mapper: {
      ...Mappers.RealTimeStateScope,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {},
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllJobsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.connectionId,
    Parameters.schemaId,
    Parameters.shapeId,
    Parameters.agentId,
    Parameters.type,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Job"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/jobs",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Job,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Job
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getPagedStatusesForJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs/{id}/status",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.page,
    Parameters.pageSize
  ],
  responses: {
    200: {
      bodyMapper: Mappers.PagedResultOfJobStatus
    },
    default: {}
  },
  serializer
};

const eventsPlaceholderForJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs/events",
  responses: {
    200: {
      bodyMapper: Mappers.DataflowEvent
    },
    default: {}
  },
  serializer
};

const getOneJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Job
    },
    default: {}
  },
  serializer
};

const updateJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/jobs/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Job,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Job
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Job
    },
    default: {}
  },
  serializer
};

const deleteJobOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/jobs/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getJobVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/jobs/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Job"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllSchemaProfilesOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemaprofiles",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.connectionId,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SchemaProfile"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createSchemaProfileOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/schemaprofiles",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.SchemaProfile,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.SchemaProfile
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneSchemaProfileOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemaprofiles/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.SchemaProfile
    },
    default: {}
  },
  serializer
};

const updateSchemaProfileOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/schemaprofiles/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.SchemaProfile,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.SchemaProfile
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.SchemaProfile
    },
    default: {}
  },
  serializer
};

const deleteSchemaProfileOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/schemaprofiles/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getSchemaProfileVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemaprofiles/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "SchemaProfile"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllSchemasOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemas",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.discoveredId,
    Parameters.discoveredName,
    Parameters.discoveredDescription,
    Parameters.query,
    Parameters.connectionId,
    Parameters.profilingJobId,
    Parameters.publisherMetaJson,
    Parameters.capability,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Schema"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createSchemaOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/schemas",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Schema,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Schema
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneSchemaOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemas/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Schema
    },
    default: {}
  },
  serializer
};

const updateSchemaOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/schemas/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Schema,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Schema
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Schema
    },
    default: {}
  },
  serializer
};

const deleteSchemaOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/schemas/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getSchemaVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/schemas/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Schema"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getAllShapesOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/shapes",
  queryParameters: [
    Parameters.id1,
    Parameters.name,
    Parameters.description,
    Parameters.copiedFromSchemaId,
    Parameters.createdBy,
    Parameters.updatedBy,
    Parameters.deletedBy
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Shape"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const createShapeOperationSpec: msRest.OperationSpec = {
  httpMethod: "POST",
  path: "v1/shapes",
  requestBody: {
    parameterPath: "input",
    mapper: {
      ...Mappers.Shape,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    201: {
      bodyMapper: Mappers.Shape
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

const getOneShapeOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/shapes/{id}",
  urlParameters: [
    Parameters.id0
  ],
  queryParameters: [
    Parameters.version
  ],
  responses: {
    200: {
      bodyMapper: Mappers.Shape
    },
    default: {}
  },
  serializer
};

const updateShapeOperationSpec: msRest.OperationSpec = {
  httpMethod: "PUT",
  path: "v1/shapes/{id}",
  urlParameters: [
    Parameters.id0
  ],
  requestBody: {
    parameterPath: "model",
    mapper: {
      ...Mappers.Shape,
      required: true
    }
  },
  contentType: "application/json-patch+json; charset=utf-8",
  responses: {
    202: {
      bodyMapper: Mappers.Shape
    },
    400: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Dictionary",
          value: {
            type: {
              name: "Sequence",
              element: {
                type: {
                  name: "String"
                }
              }
            }
          }
        }
      }
    },
    404: {},
    409: {
      bodyMapper: Mappers.Shape
    },
    default: {}
  },
  serializer
};

const deleteShapeOperationSpec: msRest.OperationSpec = {
  httpMethod: "DELETE",
  path: "v1/shapes/{id}",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {},
    default: {}
  },
  serializer
};

const getShapeVersionsOperationSpec: msRest.OperationSpec = {
  httpMethod: "GET",
  path: "v1/shapes/{id}/versions",
  urlParameters: [
    Parameters.id0
  ],
  responses: {
    200: {
      bodyMapper: {
        serializedName: "parsedResponse",
        type: {
          name: "Sequence",
          element: {
            type: {
              name: "Composite",
              className: "Shape"
            }
          }
        }
      }
    },
    default: {}
  },
  serializer
};

export {
  MetabaseApi,
  MetabaseApiContext,
  Models as MetabaseApiModels,
  Mappers as MetabaseApiMappers
};