/**
 * Generated by orval v8.19.0 🍺
 * Do not edit manually.
 * Webitel API
 * OpenAPI spec version: 24.04.0
 */
import { faker } from '@faker-js/faker';
import type { RequestHandlerOptions } from 'msw';
import { HttpResponse, http } from 'msw';

import type {
	EngineEmptyResponse,
	EngineListOutboundResource,
	EngineListOutboundResourceDisplay,
	EngineListResourceDisplay,
	EngineOutboundResource,
	EngineResourceDisplay,
} from '../_models';

export const getSearchOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineListOutboundResource, object>> = {},
): EngineListOutboundResource => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			parameters: faker.helpers.arrayElement([
				{
					cidType: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					ignoreEarlyMedia: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
				},
				undefined,
			]),
			createdAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			createdBy: faker.helpers.arrayElement([
				{
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
				},
				undefined,
			]),
			description: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			domainId: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			enabled: faker.helpers.arrayElement([
				faker.datatype.boolean(),
				undefined,
			]),
			errorIds: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() =>
					faker.string.alpha({
						length: {
							min: 10,
							max: 20,
						},
					}),
				),
				undefined,
			]),
			failureDialDelay: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			gateway: faker.helpers.arrayElement([
				{
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
				},
				undefined,
			]),
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			lastErrorAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			lastErrorId: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			maxSuccessivelyErrors: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			number: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			patterns: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() =>
					faker.string.alpha({
						length: {
							min: 10,
							max: 20,
						},
					}),
				),
				undefined,
			]),
			reserve: faker.helpers.arrayElement([
				faker.datatype.boolean(),
				undefined,
			]),
			rps: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			successivelyErrors: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			updatedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			updatedBy: faker.helpers.arrayElement([
				{
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
				},
				undefined,
			]),
			variables: faker.helpers.arrayElement([
				{
					[faker.string.alphanumeric(5)]: faker.string.alpha({
						length: {
							min: 10,
							max: 20,
						},
					}),
				},
				undefined,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	...overrideResponse,
});

export const getCreateOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineOutboundResource, object>> = {},
): EngineOutboundResource => ({
	parameters: faker.helpers.arrayElement([
		{
			cidType: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			ignoreEarlyMedia: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	createdAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	createdBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	description: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	domainId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	enabled: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	errorIds: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	failureDialDelay: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	gateway: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	limit: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	maxSuccessivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	name: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	number: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	patterns: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	reserve: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	rps: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	successivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	updatedAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	updatedBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	variables: faker.helpers.arrayElement([
		{
			[faker.string.alphanumeric(5)]: faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getDeleteOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineOutboundResource, object>> = {},
): EngineOutboundResource => ({
	parameters: faker.helpers.arrayElement([
		{
			cidType: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			ignoreEarlyMedia: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	createdAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	createdBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	description: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	domainId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	enabled: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	errorIds: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	failureDialDelay: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	gateway: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	limit: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	maxSuccessivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	name: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	number: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	patterns: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	reserve: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	rps: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	successivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	updatedAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	updatedBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	variables: faker.helpers.arrayElement([
		{
			[faker.string.alphanumeric(5)]: faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getReadOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineOutboundResource, object>> = {},
): EngineOutboundResource => ({
	parameters: faker.helpers.arrayElement([
		{
			cidType: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			ignoreEarlyMedia: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	createdAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	createdBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	description: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	domainId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	enabled: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	errorIds: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	failureDialDelay: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	gateway: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	limit: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	maxSuccessivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	name: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	number: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	patterns: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	reserve: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	rps: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	successivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	updatedAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	updatedBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	variables: faker.helpers.arrayElement([
		{
			[faker.string.alphanumeric(5)]: faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getPatchOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineOutboundResource, object>> = {},
): EngineOutboundResource => ({
	parameters: faker.helpers.arrayElement([
		{
			cidType: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			ignoreEarlyMedia: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	createdAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	createdBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	description: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	domainId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	enabled: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	errorIds: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	failureDialDelay: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	gateway: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	limit: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	maxSuccessivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	name: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	number: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	patterns: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	reserve: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	rps: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	successivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	updatedAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	updatedBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	variables: faker.helpers.arrayElement([
		{
			[faker.string.alphanumeric(5)]: faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getUpdateOutboundResourceResponseMock = (
	overrideResponse: Partial<Extract<EngineOutboundResource, object>> = {},
): EngineOutboundResource => ({
	parameters: faker.helpers.arrayElement([
		{
			cidType: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			ignoreEarlyMedia: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	createdAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	createdBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	description: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	domainId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	enabled: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	errorIds: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	failureDialDelay: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	gateway: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	lastErrorId: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	limit: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	maxSuccessivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	name: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	number: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	patterns: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	reserve: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	rps: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	successivelyErrors: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	updatedAt: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	updatedBy: faker.helpers.arrayElement([
		{
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		},
		undefined,
	]),
	variables: faker.helpers.arrayElement([
		{
			[faker.string.alphanumeric(5)]: faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getDeleteOutboundResourceDisplaysResponseMock =
	(): EngineEmptyResponse => ({});

export const getSearchOutboundResourceDisplayResponseMock = (
	overrideResponse: Partial<
		Extract<EngineListOutboundResourceDisplay, object>
	> = {},
): EngineListOutboundResourceDisplay => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			display: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	...overrideResponse,
});

export const getCreateOutboundResourceDisplayResponseMock = (
	overrideResponse: Partial<Extract<EngineResourceDisplay, object>> = {},
): EngineResourceDisplay => ({
	display: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	...overrideResponse,
});

export const getCreateOutboundResourceDisplayBulkResponseMock = (
	overrideResponse: Partial<Extract<EngineListResourceDisplay, object>> = {},
): EngineListResourceDisplay => ({
	id: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() =>
			faker.string.alpha({
				length: {
					min: 10,
					max: 20,
				},
			}),
		),
		undefined,
	]),
	...overrideResponse,
});

export const getDeleteOutboundResourceDisplayResponseMock = (
	overrideResponse: Partial<Extract<EngineResourceDisplay, object>> = {},
): EngineResourceDisplay => ({
	display: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	...overrideResponse,
});

export const getReadOutboundResourceDisplayResponseMock = (
	overrideResponse: Partial<Extract<EngineResourceDisplay, object>> = {},
): EngineResourceDisplay => ({
	display: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	...overrideResponse,
});

export const getUpdateOutboundResourceDisplayResponseMock = (
	overrideResponse: Partial<Extract<EngineResourceDisplay, object>> = {},
): EngineResourceDisplay => ({
	display: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	id: faker.helpers.arrayElement([
		faker.string.alpha({
			length: {
				min: 10,
				max: 20,
			},
		}),
		undefined,
	]),
	...overrideResponse,
});

export const getSearchOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineListOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) => Promise<EngineListOutboundResource> | EngineListOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/call_center/resources',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getSearchOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getCreateOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.post>[1]>[0],
		  ) => Promise<EngineOutboundResource> | EngineOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.post(
		'*/call_center/resources',
		async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getCreateOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getDeleteOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.delete>[1]>[0],
		  ) => Promise<EngineOutboundResource> | EngineOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.delete(
		'*/call_center/resources/:id',
		async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getDeleteOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getReadOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) => Promise<EngineOutboundResource> | EngineOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/call_center/resources/:id',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getReadOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getPatchOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.patch>[1]>[0],
		  ) => Promise<EngineOutboundResource> | EngineOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.patch(
		'*/call_center/resources/:id',
		async (info: Parameters<Parameters<typeof http.patch>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getPatchOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getUpdateOutboundResourceMockHandler = (
	overrideResponse?:
		| EngineOutboundResource
		| ((
				info: Parameters<Parameters<typeof http.put>[1]>[0],
		  ) => Promise<EngineOutboundResource> | EngineOutboundResource),
	options?: RequestHandlerOptions,
) => {
	return http.put(
		'*/call_center/resources/:id',
		async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getUpdateOutboundResourceResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getDeleteOutboundResourceDisplaysMockHandler = (
	overrideResponse?:
		| EngineEmptyResponse
		| ((
				info: Parameters<Parameters<typeof http.delete>[1]>[0],
		  ) => Promise<EngineEmptyResponse> | EngineEmptyResponse),
	options?: RequestHandlerOptions,
) => {
	return http.delete(
		'*/call_center/resources/:resourceId/display',
		async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getDeleteOutboundResourceDisplaysResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getSearchOutboundResourceDisplayMockHandler = (
	overrideResponse?:
		| EngineListOutboundResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) =>
				| Promise<EngineListOutboundResourceDisplay>
				| EngineListOutboundResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/call_center/resources/:resourceId/display',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getSearchOutboundResourceDisplayResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getCreateOutboundResourceDisplayMockHandler = (
	overrideResponse?:
		| EngineResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.post>[1]>[0],
		  ) => Promise<EngineResourceDisplay> | EngineResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.post(
		'*/call_center/resources/:resourceId/display',
		async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getCreateOutboundResourceDisplayResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getCreateOutboundResourceDisplayBulkMockHandler = (
	overrideResponse?:
		| EngineListResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.post>[1]>[0],
		  ) => Promise<EngineListResourceDisplay> | EngineListResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.post(
		'*/call_center/resources/:resourceId/display/bulk',
		async (info: Parameters<Parameters<typeof http.post>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getCreateOutboundResourceDisplayBulkResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getDeleteOutboundResourceDisplayMockHandler = (
	overrideResponse?:
		| EngineResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.delete>[1]>[0],
		  ) => Promise<EngineResourceDisplay> | EngineResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.delete(
		'*/call_center/resources/:resourceId/display/:id',
		async (info: Parameters<Parameters<typeof http.delete>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getDeleteOutboundResourceDisplayResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getReadOutboundResourceDisplayMockHandler = (
	overrideResponse?:
		| EngineResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) => Promise<EngineResourceDisplay> | EngineResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/call_center/resources/:resourceId/display/:id',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getReadOutboundResourceDisplayResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

export const getUpdateOutboundResourceDisplayMockHandler = (
	overrideResponse?:
		| EngineResourceDisplay
		| ((
				info: Parameters<Parameters<typeof http.put>[1]>[0],
		  ) => Promise<EngineResourceDisplay> | EngineResourceDisplay),
	options?: RequestHandlerOptions,
) => {
	return http.put(
		'*/call_center/resources/:resourceId/display/:id',
		async (info: Parameters<Parameters<typeof http.put>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getUpdateOutboundResourceDisplayResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};
export const getOutboundResourceServiceMock = () => [
	getSearchOutboundResourceMockHandler(),
	getCreateOutboundResourceMockHandler(),
	getDeleteOutboundResourceMockHandler(),
	getReadOutboundResourceMockHandler(),
	getPatchOutboundResourceMockHandler(),
	getUpdateOutboundResourceMockHandler(),
	getDeleteOutboundResourceDisplaysMockHandler(),
	getSearchOutboundResourceDisplayMockHandler(),
	getCreateOutboundResourceDisplayMockHandler(),
	getCreateOutboundResourceDisplayBulkMockHandler(),
	getDeleteOutboundResourceDisplayMockHandler(),
	getReadOutboundResourceDisplayMockHandler(),
	getUpdateOutboundResourceDisplayMockHandler(),
];