import { HttpResponse } from './HttpResponse.js';
import { PayloadSerializer } from '../lib/transformers/PayloadSerializer.js';
import { Normalizer } from './legacy/Normalizer.js';
import { SerializableError } from './SerializableError.js';
import { HttpResponseKind } from './kinds.js';
export class ErrorResponse extends HttpResponse {
    /**
     * An error associated with the response
     */
    error = new SerializableError('Unknown error');
    /**
     * @returns The same Error or new Error instance when passed string.
     */
    static ensureError(error) {
        if (typeof error === 'string') {
            return new SerializableError(error);
        }
        if (error.name === 'SerializableError') {
            return error;
        }
        return new SerializableError(error);
    }
    /**
     * @param error The error message or Error object to use.
     */
    static fromError(error) {
        return new ErrorResponse({
            kind: HttpResponseKind,
            status: 0,
            error: ErrorResponse.ensureError(error).toJSON(),
        });
    }
    static async fromLegacy(input) {
        const init = {
            kind: HttpResponseKind,
            status: input.status || 0,
            error: input.error
                ? ErrorResponse.ensureError(input.error).toJSON()
                : new SerializableError('Unknown error').toJSON(),
        };
        if (input.headers) {
            init.headers = input.headers;
        }
        if (input.statusText) {
            init.statusText = input.statusText;
        }
        if (input.payload) {
            const orig = Normalizer.restoreTransformedPayload(input.payload);
            if (orig) {
                init.payload = await PayloadSerializer.serialize(orig);
            }
        }
        return new ErrorResponse(init);
    }
    /**
     * @param input The request definition used to restore the state.
     */
    constructor(input) {
        super(input);
        let init;
        if (typeof input === 'string') {
            init = JSON.parse(input);
        }
        else if (typeof input === 'object') {
            init = input;
        }
        else {
            init = {
                kind: HttpResponseKind,
                status: 0,
                error: new SerializableError('Unknown error').toJSON(),
            };
        }
        this.new(init);
    }
    /**
     * Creates a new request clearing anything that is so far defined.
     *
     * Note, this throws an error when the object is not an API Client request.
     */
    new(init) {
        super.new(init);
        if (init.error) {
            if (typeof init.error === 'string') {
                this.error = new SerializableError(init.error);
            }
            else {
                this.error = new SerializableError();
                this.error.new(init.error);
            }
        }
    }
    toJSON() {
        const response = super.toJSON();
        response.error = this.error.toJSON();
        return response;
    }
    static isErrorResponse(input) {
        const typed = input;
        return !!typed.error;
    }
}
//# sourceMappingURL=ErrorResponse.js.map