import { ResponseContext, RequestContext, HttpFile, HttpInfo } from '../http/http';
import { Configuration} from '../configuration'
import { Observable, of, from } from '../rxjsStub';
import {mergeMap, map} from  '../rxjsStub';
import { EmailRecipient } from '../models/EmailRecipient';
import { EmailSender } from '../models/EmailSender';
import { MailMessage } from '../models/MailMessage';
import { ModelError } from '../models/ModelError';
import { SendBulkMailRequest } from '../models/SendBulkMailRequest';
import { SendBulkMailResponse } from '../models/SendBulkMailResponse';
import { SendBulkMailResponseFailedInner } from '../models/SendBulkMailResponseFailedInner';
import { SendBulkMailResponseSuccessfulInner } from '../models/SendBulkMailResponseSuccessfulInner';
import { SendMailRequest } from '../models/SendMailRequest';
import { SendMailResponse } from '../models/SendMailResponse';
import { SendSMSRequest } from '../models/SendSMSRequest';
import { SendSMSResponse } from '../models/SendSMSResponse';
import { SendSlackMessageRequest } from '../models/SendSlackMessageRequest';
import { SendSlackMessageResponse } from '../models/SendSlackMessageResponse';
import { SlackMessage } from '../models/SlackMessage';
import { SlackRecipient } from '../models/SlackRecipient';

import { EmailApiRequestFactory, EmailApiResponseProcessor} from "../apis/EmailApi";
export class ObservableEmailApi {
    private requestFactory: EmailApiRequestFactory;
    private responseProcessor: EmailApiResponseProcessor;
    private configuration: Configuration;

    public constructor(
        configuration: Configuration,
        requestFactory?: EmailApiRequestFactory,
        responseProcessor?: EmailApiResponseProcessor
    ) {
        this.configuration = configuration;
        this.requestFactory = requestFactory || new EmailApiRequestFactory(configuration);
        this.responseProcessor = responseProcessor || new EmailApiResponseProcessor();
    }

    /**
     * Send a batch of multiple emails to individual recipients with the same content. Note that if cc or bcc address are provided, each email sent will also be sent to any addresses in these lists. Note that it is possible for only a subset of these to fail 
     * @param sendBulkMailRequest Parameters of the messages to send
     */
    public sendBulkWithHttpInfo(sendBulkMailRequest: SendBulkMailRequest, _options?: Configuration): Observable<HttpInfo<SendBulkMailResponse>> {
        const requestContextPromise = this.requestFactory.sendBulk(sendBulkMailRequest, _options);

        // build promise chain
        let middlewarePreObservable = from<RequestContext>(requestContextPromise);
        for (let middleware of this.configuration.middleware) {
            middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
        }

        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
            pipe(mergeMap((response: ResponseContext) => {
                let middlewarePostObservable = of(response);
                for (let middleware of this.configuration.middleware) {
                    middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                }
                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.sendBulkWithHttpInfo(rsp)));
            }));
    }

    /**
     * Send a batch of multiple emails to individual recipients with the same content. Note that if cc or bcc address are provided, each email sent will also be sent to any addresses in these lists. Note that it is possible for only a subset of these to fail 
     * @param sendBulkMailRequest Parameters of the messages to send
     */
    public sendBulk(sendBulkMailRequest: SendBulkMailRequest, _options?: Configuration): Observable<SendBulkMailResponse> {
        return this.sendBulkWithHttpInfo(sendBulkMailRequest, _options).pipe(map((apiResponse: HttpInfo<SendBulkMailResponse>) => apiResponse.data));
    }

    /**
     * Send a single email. Note that if multiple to addresses are provided it will still only send a single email with multiple addresses in the to field. To send multiple emails to individual addresses, see the sendBulk endpoint. 
     * @param sendMailRequest Parameters of the message to send
     */
    public sendEmailWithHttpInfo(sendMailRequest: SendMailRequest, _options?: Configuration): Observable<HttpInfo<SendMailResponse>> {
        const requestContextPromise = this.requestFactory.sendEmail(sendMailRequest, _options);

        // build promise chain
        let middlewarePreObservable = from<RequestContext>(requestContextPromise);
        for (let middleware of this.configuration.middleware) {
            middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
        }

        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
            pipe(mergeMap((response: ResponseContext) => {
                let middlewarePostObservable = of(response);
                for (let middleware of this.configuration.middleware) {
                    middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                }
                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.sendEmailWithHttpInfo(rsp)));
            }));
    }

    /**
     * Send a single email. Note that if multiple to addresses are provided it will still only send a single email with multiple addresses in the to field. To send multiple emails to individual addresses, see the sendBulk endpoint. 
     * @param sendMailRequest Parameters of the message to send
     */
    public sendEmail(sendMailRequest: SendMailRequest, _options?: Configuration): Observable<SendMailResponse> {
        return this.sendEmailWithHttpInfo(sendMailRequest, _options).pipe(map((apiResponse: HttpInfo<SendMailResponse>) => apiResponse.data));
    }

}

import { HealthApiRequestFactory, HealthApiResponseProcessor} from "../apis/HealthApi";
export class ObservableHealthApi {
    private requestFactory: HealthApiRequestFactory;
    private responseProcessor: HealthApiResponseProcessor;
    private configuration: Configuration;

    public constructor(
        configuration: Configuration,
        requestFactory?: HealthApiRequestFactory,
        responseProcessor?: HealthApiResponseProcessor
    ) {
        this.configuration = configuration;
        this.requestFactory = requestFactory || new HealthApiRequestFactory(configuration);
        this.responseProcessor = responseProcessor || new HealthApiResponseProcessor();
    }

    /**
     * Readiness check - the service is ready to handle work
     */
    public readyCheckWithHttpInfo(_options?: Configuration): Observable<HttpInfo<string>> {
        const requestContextPromise = this.requestFactory.readyCheck(_options);

        // build promise chain
        let middlewarePreObservable = from<RequestContext>(requestContextPromise);
        for (let middleware of this.configuration.middleware) {
            middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
        }

        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
            pipe(mergeMap((response: ResponseContext) => {
                let middlewarePostObservable = of(response);
                for (let middleware of this.configuration.middleware) {
                    middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                }
                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.readyCheckWithHttpInfo(rsp)));
            }));
    }

    /**
     * Readiness check - the service is ready to handle work
     */
    public readyCheck(_options?: Configuration): Observable<string> {
        return this.readyCheckWithHttpInfo(_options).pipe(map((apiResponse: HttpInfo<string>) => apiResponse.data));
    }

}

import { NotificationApiRequestFactory, NotificationApiResponseProcessor} from "../apis/NotificationApi";
export class ObservableNotificationApi {
    private requestFactory: NotificationApiRequestFactory;
    private responseProcessor: NotificationApiResponseProcessor;
    private configuration: Configuration;

    public constructor(
        configuration: Configuration,
        requestFactory?: NotificationApiRequestFactory,
        responseProcessor?: NotificationApiResponseProcessor
    ) {
        this.configuration = configuration;
        this.requestFactory = requestFactory || new NotificationApiRequestFactory(configuration);
        this.responseProcessor = responseProcessor || new NotificationApiResponseProcessor();
    }

    /**
     * Send a Slack message
     * @param sendSlackMessageRequest Parameters of the message to send
     */
    public sendSlackNotificationWithHttpInfo(sendSlackMessageRequest: SendSlackMessageRequest, _options?: Configuration): Observable<HttpInfo<SendSlackMessageResponse>> {
        const requestContextPromise = this.requestFactory.sendSlackNotification(sendSlackMessageRequest, _options);

        // build promise chain
        let middlewarePreObservable = from<RequestContext>(requestContextPromise);
        for (let middleware of this.configuration.middleware) {
            middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
        }

        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
            pipe(mergeMap((response: ResponseContext) => {
                let middlewarePostObservable = of(response);
                for (let middleware of this.configuration.middleware) {
                    middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                }
                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.sendSlackNotificationWithHttpInfo(rsp)));
            }));
    }

    /**
     * Send a Slack message
     * @param sendSlackMessageRequest Parameters of the message to send
     */
    public sendSlackNotification(sendSlackMessageRequest: SendSlackMessageRequest, _options?: Configuration): Observable<SendSlackMessageResponse> {
        return this.sendSlackNotificationWithHttpInfo(sendSlackMessageRequest, _options).pipe(map((apiResponse: HttpInfo<SendSlackMessageResponse>) => apiResponse.data));
    }

}

import { SmsApiRequestFactory, SmsApiResponseProcessor} from "../apis/SmsApi";
export class ObservableSmsApi {
    private requestFactory: SmsApiRequestFactory;
    private responseProcessor: SmsApiResponseProcessor;
    private configuration: Configuration;

    public constructor(
        configuration: Configuration,
        requestFactory?: SmsApiRequestFactory,
        responseProcessor?: SmsApiResponseProcessor
    ) {
        this.configuration = configuration;
        this.requestFactory = requestFactory || new SmsApiRequestFactory(configuration);
        this.responseProcessor = responseProcessor || new SmsApiResponseProcessor();
    }

    /**
     * Send an SMS
     * @param sendSMSRequest Parameters of the message to send
     */
    public sendSMSWithHttpInfo(sendSMSRequest: SendSMSRequest, _options?: Configuration): Observable<HttpInfo<string>> {
        const requestContextPromise = this.requestFactory.sendSMS(sendSMSRequest, _options);

        // build promise chain
        let middlewarePreObservable = from<RequestContext>(requestContextPromise);
        for (let middleware of this.configuration.middleware) {
            middlewarePreObservable = middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => middleware.pre(ctx)));
        }

        return middlewarePreObservable.pipe(mergeMap((ctx: RequestContext) => this.configuration.httpApi.send(ctx))).
            pipe(mergeMap((response: ResponseContext) => {
                let middlewarePostObservable = of(response);
                for (let middleware of this.configuration.middleware) {
                    middlewarePostObservable = middlewarePostObservable.pipe(mergeMap((rsp: ResponseContext) => middleware.post(rsp)));
                }
                return middlewarePostObservable.pipe(map((rsp: ResponseContext) => this.responseProcessor.sendSMSWithHttpInfo(rsp)));
            }));
    }

    /**
     * Send an SMS
     * @param sendSMSRequest Parameters of the message to send
     */
    public sendSMS(sendSMSRequest: SendSMSRequest, _options?: Configuration): Observable<string> {
        return this.sendSMSWithHttpInfo(sendSMSRequest, _options).pipe(map((apiResponse: HttpInfo<string>) => apiResponse.data));
    }

}