/**
 * 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 {
	ApiGetCustomerResponse,
	ApiLicenseUsageResponse,
	ApiLicenseUsersResponse,
	ApiServerInfoResponse,
	ApiUpdateCustomerResponse,
} from '../_models';

export const getGetCustomerResponseMock = (
	overrideResponse: Partial<Extract<ApiGetCustomerResponse, object>> = {},
): ApiGetCustomerResponse => ({
	customer: faker.helpers.arrayElement([
		{
			createdAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			dnsrv: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					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,
			]),
			issuedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			license: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					competitive: faker.helpers.arrayElement([
						faker.datatype.boolean(),
						undefined,
					]),
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					limit: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notAfter: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notBefore: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					product: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					remain: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					scope: 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,
					]),
					status: faker.helpers.arrayElement([
						{
							errors: 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,
							]),
							notify: 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,
							]),
						},
						undefined,
					]),
					users: faker.helpers.arrayElement([
						Array.from(
							{
								length: faker.number.int({
									min: 1,
									max: 10,
								}),
							},
							(_, i) => i + 1,
						).map(() => ({
							expiresAt: 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,
							]),
							issuedAt: 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,
							]),
							prod: faker.helpers.arrayElement([
								faker.string.alpha({
									length: {
										min: 10,
										max: 20,
									},
								}),
								undefined,
							]),
							scope: 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,
							]),
							user: 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,
							]),
						})),
						undefined,
					]),
				})),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				{
					[faker.string.alphanumeric(5)]: faker.number.int(),
				},
				undefined,
			]),
			nextUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			organization: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			revokedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			thisUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			updatedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			verify: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getUpdateCustomerResponseMock = (
	overrideResponse: Partial<Extract<ApiUpdateCustomerResponse, object>> = {},
): ApiUpdateCustomerResponse => ({
	customer: faker.helpers.arrayElement([
		{
			createdAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			dnsrv: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					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,
			]),
			issuedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			license: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					competitive: faker.helpers.arrayElement([
						faker.datatype.boolean(),
						undefined,
					]),
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					limit: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notAfter: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notBefore: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					product: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					remain: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					scope: 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,
					]),
					status: faker.helpers.arrayElement([
						{
							errors: 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,
							]),
							notify: 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,
							]),
						},
						undefined,
					]),
					users: faker.helpers.arrayElement([
						Array.from(
							{
								length: faker.number.int({
									min: 1,
									max: 10,
								}),
							},
							(_, i) => i + 1,
						).map(() => ({
							expiresAt: 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,
							]),
							issuedAt: 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,
							]),
							prod: faker.helpers.arrayElement([
								faker.string.alpha({
									length: {
										min: 10,
										max: 20,
									},
								}),
								undefined,
							]),
							scope: 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,
							]),
							user: 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,
							]),
						})),
						undefined,
					]),
				})),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				{
					[faker.string.alphanumeric(5)]: faker.number.int(),
				},
				undefined,
			]),
			nextUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			organization: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			revokedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			thisUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			updatedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			verify: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getLicenseUsageResponseMock = (
	overrideResponse: Partial<Extract<ApiLicenseUsageResponse, object>> = {},
): ApiLicenseUsageResponse => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			competitive: faker.helpers.arrayElement([
				faker.datatype.boolean(),
				undefined,
			]),
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			product: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			remain: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			scope: 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,
			]),
			status: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
			users: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					expiresAt: 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,
					]),
					issuedAt: 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,
					]),
					prod: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					scope: 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,
					]),
					user: 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,
					]),
				})),
				undefined,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	page: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	...overrideResponse,
});

export const getGetCustomer2ResponseMock = (
	overrideResponse: Partial<Extract<ApiGetCustomerResponse, object>> = {},
): ApiGetCustomerResponse => ({
	customer: faker.helpers.arrayElement([
		{
			createdAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			dnsrv: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					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,
			]),
			issuedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			license: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					competitive: faker.helpers.arrayElement([
						faker.datatype.boolean(),
						undefined,
					]),
					id: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					limit: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					name: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notAfter: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					notBefore: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					product: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					remain: faker.helpers.arrayElement([
						faker.number.int(),
						undefined,
					]),
					scope: 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,
					]),
					status: faker.helpers.arrayElement([
						{
							errors: 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,
							]),
							notify: 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,
							]),
						},
						undefined,
					]),
					users: faker.helpers.arrayElement([
						Array.from(
							{
								length: faker.number.int({
									min: 1,
									max: 10,
								}),
							},
							(_, i) => i + 1,
						).map(() => ({
							expiresAt: 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,
							]),
							issuedAt: 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,
							]),
							prod: faker.helpers.arrayElement([
								faker.string.alpha({
									length: {
										min: 10,
										max: 20,
									},
								}),
								undefined,
							]),
							scope: 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,
							]),
							user: 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,
							]),
						})),
						undefined,
					]),
				})),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				{
					[faker.string.alphanumeric(5)]: faker.number.int(),
				},
				undefined,
			]),
			nextUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			organization: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			revokedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			thisUpdate: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			updatedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			verify: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
		},
		undefined,
	]),
	...overrideResponse,
});

export const getLicenseUsage2ResponseMock = (
	overrideResponse: Partial<Extract<ApiLicenseUsageResponse, object>> = {},
): ApiLicenseUsageResponse => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			competitive: faker.helpers.arrayElement([
				faker.datatype.boolean(),
				undefined,
			]),
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			product: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			remain: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			scope: 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,
			]),
			status: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
			users: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					expiresAt: 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,
					]),
					issuedAt: 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,
					]),
					prod: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					scope: 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,
					]),
					user: 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,
					]),
				})),
				undefined,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	page: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	...overrideResponse,
});

export const getLicenseUsage3ResponseMock = (
	overrideResponse: Partial<Extract<ApiLicenseUsageResponse, object>> = {},
): ApiLicenseUsageResponse => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			competitive: faker.helpers.arrayElement([
				faker.datatype.boolean(),
				undefined,
			]),
			id: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			limit: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			name: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notAfter: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			notBefore: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			product: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			remain: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			scope: 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,
			]),
			status: faker.helpers.arrayElement([
				{
					errors: 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,
					]),
					notify: 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,
					]),
				},
				undefined,
			]),
			users: faker.helpers.arrayElement([
				Array.from(
					{
						length: faker.number.int({
							min: 1,
							max: 10,
						}),
					},
					(_, i) => i + 1,
				).map(() => ({
					expiresAt: 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,
					]),
					issuedAt: 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,
					]),
					prod: faker.helpers.arrayElement([
						faker.string.alpha({
							length: {
								min: 10,
								max: 20,
							},
						}),
						undefined,
					]),
					scope: 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,
					]),
					user: 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,
					]),
				})),
				undefined,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	page: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	...overrideResponse,
});

export const getLicenseUsersResponseMock = (
	overrideResponse: Partial<Extract<ApiLicenseUsersResponse, object>> = {},
): ApiLicenseUsersResponse => ({
	items: faker.helpers.arrayElement([
		Array.from(
			{
				length: faker.number.int({
					min: 1,
					max: 10,
				}),
			},
			(_, i) => i + 1,
		).map(() => ({
			domain: 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,
			]),
			expiresAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			issuedAt: faker.helpers.arrayElement([
				faker.string.alpha({
					length: {
						min: 10,
						max: 20,
					},
				}),
				undefined,
			]),
			sessions: faker.helpers.arrayElement([
				faker.number.int(),
				undefined,
			]),
			user: 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,
			]),
		})),
		undefined,
	]),
	next: faker.helpers.arrayElement([
		faker.datatype.boolean(),
		undefined,
	]),
	page: faker.helpers.arrayElement([
		faker.number.int(),
		undefined,
	]),
	...overrideResponse,
});

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

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

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

export const getLicenseUsageMockHandler = (
	overrideResponse?:
		| ApiLicenseUsageResponse
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) => Promise<ApiLicenseUsageResponse> | ApiLicenseUsageResponse),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/customer/:customerId/license',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getLicenseUsageResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};

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

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

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

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

export const getServerInfoMockHandler = (
	overrideResponse?:
		| ApiServerInfoResponse
		| ((
				info: Parameters<Parameters<typeof http.get>[1]>[0],
		  ) => Promise<ApiServerInfoResponse> | ApiServerInfoResponse),
	options?: RequestHandlerOptions,
) => {
	return http.get(
		'*/srvinfo',
		async (info: Parameters<Parameters<typeof http.get>[1]>[0]) => {
			return HttpResponse.json(
				overrideResponse !== undefined
					? typeof overrideResponse === 'function'
						? await overrideResponse(info)
						: overrideResponse
					: getServerInfoResponseMock(),
				{
					status: 200,
				},
			);
		},
		options,
	);
};
export const getCustomersMock = () => [
	getGetCustomerMockHandler(),
	getUpdateCustomerMockHandler(),
	getLicenseUsageMockHandler(),
	getGetCustomer2MockHandler(),
	getLicenseUsage2MockHandler(),
	getLicenseUsage3MockHandler(),
	getLicenseUsersMockHandler(),
	getServerInfoMockHandler(),
];