diff --git a/.gitignore b/.gitignore index e5639d6ed..b57d3733f 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ yarn-error.log* dist coverage .env +.svelte-kit # test files test/generated diff --git a/.prettierignore b/.prettierignore index 966ec8a76..f8b7cc177 100644 --- a/.prettierignore +++ b/.prettierignore @@ -2,6 +2,7 @@ **/node_modules **/templates **/dist +**/.svelte-kit **/.vitepress/cache **/.vitepress/dist **/test/e2e diff --git a/eslint.config.js b/eslint.config.js index 4abf169a9..09b7e5a45 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -51,6 +51,7 @@ export default tseslint.config( 'temp/', '**/test/e2e/generated/', '**/test/generated/', + '**/.svelte-kit/', '**/.vitepress/cache', '**/.vitepress/dist', ], diff --git a/examples/openapi-ts-tanstack-svelte-query/.gitignore b/examples/openapi-ts-tanstack-svelte-query/.gitignore new file mode 100644 index 000000000..298c335df --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/.gitignore @@ -0,0 +1,45 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? + +node_modules + +# Output +.output +.vercel +.svelte-kit +/build + +# OS +.DS_Store +Thumbs.db + +# Env +.env +.env.* +!.env.example +!.env.test + +# Vite +vite.config.js.timestamp-* +vite.config.ts.timestamp-* diff --git a/examples/openapi-ts-tanstack-svelte-query/README.md b/examples/openapi-ts-tanstack-svelte-query/README.md new file mode 100644 index 000000000..5ce676612 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/README.md @@ -0,0 +1,38 @@ +# create-svelte + +Everything you need to build a Svelte project, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte). + +## Creating a project + +If you're seeing this, you've probably already done this step. Congrats! + +```bash +# create a new project in the current directory +npm create svelte@latest + +# create a new project in my-app +npm create svelte@latest my-app +``` + +## Developing + +Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server: + +```bash +npm run dev + +# or start the server and open the app in a new browser tab +npm run dev -- --open +``` + +## Building + +To create a production version of your app: + +```bash +npm run build +``` + +You can preview the production build with `npm run preview`. + +> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment. diff --git a/examples/openapi-ts-tanstack-svelte-query/openapi-ts.config.ts b/examples/openapi-ts-tanstack-svelte-query/openapi-ts.config.ts new file mode 100644 index 000000000..ef5a4617d --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/openapi-ts.config.ts @@ -0,0 +1,18 @@ +import { defineConfig } from '@hey-api/openapi-ts'; + +export default defineConfig({ + client: '@hey-api/client-fetch', + input: + 'https://raw.githubusercontent.com/swagger-api/swagger-petstore/master/src/main/resources/openapi.yaml', + // 'https://raw.githubusercontent.com/Redocly/museum-openapi-example/main/openapi.yaml', + // '../../packages/openapi-ts/test/spec/v3.json', + output: { + format: 'prettier', + lint: 'eslint', + path: './src/client', + }, + plugins: ['@tanstack/svelte-query'], + types: { + enums: 'javascript', + }, +}); diff --git a/examples/openapi-ts-tanstack-svelte-query/package.json b/examples/openapi-ts-tanstack-svelte-query/package.json new file mode 100644 index 000000000..539f731c9 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/package.json @@ -0,0 +1,43 @@ +{ + "name": "@example/openapi-ts-tanstack-svelte-query", + "private": true, + "version": "0.0.1", + "type": "module", + "scripts": { + "build": "vite build", + "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch", + "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json", + "dev": "vite dev", + "format": "prettier --write .", + "lint": "prettier --check . && eslint .", + "openapi-ts": "openapi-ts", + "prepare": "svelte-kit sync", + "preview": "vite preview", + "test": "vitest" + }, + "dependencies": { + "@hey-api/client-fetch": "workspace:*", + "@tanstack/svelte-query": "5.51.21" + }, + "devDependencies": { + "@fontsource/fira-mono": "5.0.0", + "@hey-api/openapi-ts": "workspace:*", + "@neoconfetti/svelte": "2.0.0", + "@sveltejs/adapter-auto": "3.0.0", + "@sveltejs/kit": "2.0.0", + "@sveltejs/vite-plugin-svelte": "3.0.0", + "@types/eslint": "9.6.0", + "eslint": "9.0.0", + "eslint-config-prettier": "9.1.0", + "eslint-plugin-svelte": "2.36.0", + "globals": "15.0.0", + "prettier": "3.1.1", + "prettier-plugin-svelte": "3.1.2", + "svelte": "4.2.7", + "svelte-check": "3.6.0", + "typescript": "5.5.3", + "typescript-eslint": "8.0.0", + "vite": "5.0.3", + "vitest": "2.0.0" + } +} diff --git a/examples/openapi-ts-tanstack-svelte-query/src/app.css b/examples/openapi-ts-tanstack-svelte-query/src/app.css new file mode 100644 index 000000000..f080f2926 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/app.css @@ -0,0 +1,112 @@ +@import '@fontsource/fira-mono'; + +:root { + --font-body: Arial, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, + Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif; + --font-mono: 'Fira Mono', monospace; + --color-bg-0: rgb(202, 216, 228); + --color-bg-1: hsl(209, 36%, 86%); + --color-bg-2: hsl(224, 44%, 95%); + --color-theme-1: #ff3e00; + --color-theme-2: #4075a6; + --color-text: rgba(0, 0, 0, 0.7); + --column-width: 42rem; + --column-margin-top: 4rem; + font-family: var(--font-body); + color: var(--color-text); +} + +body { + min-height: 100vh; + margin: 0; + background-attachment: fixed; + background-color: var(--color-bg-1); + background-size: 100vw 100vh; + background-image: radial-gradient( + 50% 50% at 50% 50%, + rgba(255, 255, 255, 0.75) 0%, + rgba(255, 255, 255, 0) 100% + ), + linear-gradient( + 180deg, + var(--color-bg-0) 0%, + var(--color-bg-1) 15%, + var(--color-bg-2) 50% + ); +} + +h1, +h2, +p { + font-weight: 400; +} + +p { + line-height: 1.5; +} + +a { + color: var(--color-theme-1); + text-decoration: none; +} + +a:hover { + text-decoration: underline; +} + +h1 { + font-size: 2rem; + text-align: center; +} + +h2 { + font-size: 1rem; +} + +pre { + font-size: 16px; + font-family: var(--font-mono); + background-color: rgba(255, 255, 255, 0.45); + border-radius: 3px; + box-shadow: 2px 2px 6px rgb(255 255 255 / 25%); + padding: 0.5em; + overflow-x: auto; + color: var(--color-text); +} + +.text-column { + display: flex; + max-width: 48rem; + flex: 0.6; + flex-direction: column; + justify-content: center; + margin: 0 auto; +} + +input, +button { + font-size: inherit; + font-family: inherit; +} + +button:focus:not(:focus-visible) { + outline: none; +} + +@media (min-width: 720px) { + h1 { + font-size: 2.4rem; + } +} + +.visually-hidden { + border: 0; + clip: rect(0 0 0 0); + height: auto; + margin: 0; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; + white-space: nowrap; +} diff --git a/examples/openapi-ts-tanstack-svelte-query/src/app.d.ts b/examples/openapi-ts-tanstack-svelte-query/src/app.d.ts new file mode 100644 index 000000000..ede601ab9 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/app.d.ts @@ -0,0 +1,13 @@ +// See https://kit.svelte.dev/docs/types#app +// for information about these interfaces +declare global { + namespace App { + // interface Error {} + // interface Locals {} + // interface PageData {} + // interface PageState {} + // interface Platform {} + } +} + +export {}; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/app.html b/examples/openapi-ts-tanstack-svelte-query/src/app.html new file mode 100644 index 000000000..84ffad166 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/app.html @@ -0,0 +1,12 @@ + + + + + + + %sveltekit.head% + + +
%sveltekit.body%
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/client/@tanstack/svelte-query.gen.ts b/examples/openapi-ts-tanstack-svelte-query/src/client/@tanstack/svelte-query.gen.ts new file mode 100644 index 000000000..7ca053403 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/client/@tanstack/svelte-query.gen.ts @@ -0,0 +1,503 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { + type DefaultError, + type MutationOptions, + queryOptions, +} from '@tanstack/svelte-query'; + +import { + addPet, + createUser, + createUsersWithListInput, + deleteOrder, + deletePet, + deleteUser, + findPetsByStatus, + findPetsByTags, + getInventory, + getOrderById, + getPetById, + getUserByName, + loginUser, + logoutUser, + placeOrder, + updatePet, + updatePetWithForm, + updateUser, + uploadFile, +} from '../services.gen'; +import type { + AddPetData, + AddPetError, + AddPetResponse, + CreateUserData, + CreateUserError, + CreateUserResponse, + CreateUsersWithListInputData, + CreateUsersWithListInputError, + CreateUsersWithListInputResponse, + DeleteOrderData, + DeletePetData, + DeleteUserData, + FindPetsByStatusData, + FindPetsByTagsData, + GetOrderByIdData, + GetPetByIdData, + GetUserByNameData, + LoginUserData, + PlaceOrderData, + PlaceOrderError, + PlaceOrderResponse, + UpdatePetData, + UpdatePetError, + UpdatePetResponse, + UpdatePetWithFormData, + UpdateUserData, + UpdateUserError, + UpdateUserResponse, + UploadFileData, + UploadFileError, + UploadFileResponse, +} from '../types.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + }, +]; + +const createQueryKeyParams = ( + options?: TOptions, +): QueryKey[0]['params'] => { + const params: QueryKey[0]['params'] = + {} as QueryKey[0]['params']; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const addPetOptions = (options: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await addPet({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'addPet', + }, + ], + }); + +export const addPetMutation: MutationOptions< + AddPetResponse, + AddPetError, + Options +> = { + mutationFn: async (options) => { + const { data } = await addPet({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const updatePetMutation: MutationOptions< + UpdatePetResponse, + UpdatePetError, + Options +> = { + mutationFn: async (options) => { + const { data } = await updatePet({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const findPetsByStatusOptions = ( + options?: Options, +) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await findPetsByStatus({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'findPetsByStatus', + }, + ], + }); + +export const findPetsByTagsOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await findPetsByTags({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'findPetsByTags', + }, + ], + }); + +export const getPetByIdOptions = (options: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getPetById({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getPetById', + }, + ], + }); + +export const updatePetWithFormOptions = ( + options: Options, +) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await updatePetWithForm({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'updatePetWithForm', + }, + ], + }); + +export const updatePetWithFormMutation: MutationOptions< + void, + DefaultError, + Options +> = { + mutationFn: async (options) => { + const { data } = await updatePetWithForm({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const deletePetMutation: MutationOptions< + void, + DefaultError, + Options +> = { + mutationFn: async (options) => { + const { data } = await deletePet({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const uploadFileOptions = (options: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile', + }, + ], + }); + +export const uploadFileMutation: MutationOptions< + UploadFileResponse, + UploadFileError, + Options +> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const getInventoryOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getInventory({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getInventory', + }, + ], + }); + +export const placeOrderOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await placeOrder({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'placeOrder', + }, + ], + }); + +export const placeOrderMutation: MutationOptions< + PlaceOrderResponse, + PlaceOrderError, + Options +> = { + mutationFn: async (options) => { + const { data } = await placeOrder({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const getOrderByIdOptions = (options: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getOrderById({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getOrderById', + }, + ], + }); + +export const deleteOrderMutation: MutationOptions< + void, + DefaultError, + Options +> = { + mutationFn: async (options) => { + const { data } = await deleteOrder({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const createUserOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await createUser({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'createUser', + }, + ], + }); + +export const createUserMutation: MutationOptions< + CreateUserResponse, + CreateUserError, + Options +> = { + mutationFn: async (options) => { + const { data } = await createUser({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const createUsersWithListInputOptions = ( + options?: Options, +) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await createUsersWithListInput({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'createUsersWithListInput', + }, + ], + }); + +export const createUsersWithListInputMutation: MutationOptions< + CreateUsersWithListInputResponse, + CreateUsersWithListInputError, + Options +> = { + mutationFn: async (options) => { + const { data } = await createUsersWithListInput({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const loginUserOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await loginUser({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'loginUser', + }, + ], + }); + +export const logoutUserOptions = (options?: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await logoutUser({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'logoutUser', + }, + ], + }); + +export const getUserByNameOptions = (options: Options) => + queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getUserByName({ + ...options, + ...queryKey[0].params, + throwOnError: true, + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getUserByName', + }, + ], + }); + +export const updateUserMutation: MutationOptions< + UpdateUserResponse, + UpdateUserError, + Options +> = { + mutationFn: async (options) => { + const { data } = await updateUser({ + ...options, + throwOnError: true, + }); + return data; + }, +}; + +export const deleteUserMutation: MutationOptions< + void, + DefaultError, + Options +> = { + mutationFn: async (options) => { + const { data } = await deleteUser({ + ...options, + throwOnError: true, + }); + return data; + }, +}; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/client/index.ts b/examples/openapi-ts-tanstack-svelte-query/src/client/index.ts new file mode 100644 index 000000000..002afc333 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/client/index.ts @@ -0,0 +1,4 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './schemas.gen'; +export * from './services.gen'; +export * from './types.gen'; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/client/schemas.gen.ts b/examples/openapi-ts-tanstack-svelte-query/src/client/schemas.gen.ts new file mode 100644 index 000000000..8f6b9dc92 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/client/schemas.gen.ts @@ -0,0 +1,244 @@ +// This file is auto-generated by @hey-api/openapi-ts + +export const $Order = { + properties: { + complete: { + type: 'boolean', + }, + id: { + example: 10, + format: 'int64', + type: 'integer', + }, + petId: { + example: 198772, + format: 'int64', + type: 'integer', + }, + quantity: { + example: 7, + format: 'int32', + type: 'integer', + }, + shipDate: { + format: 'date-time', + type: 'string', + }, + status: { + description: 'Order Status', + enum: ['placed', 'approved', 'delivered'], + example: 'approved', + type: 'string', + }, + }, + type: 'object', + 'x-swagger-router-model': 'io.swagger.petstore.model.Order', + xml: { + name: 'order', + }, +} as const; + +export const $Customer = { + properties: { + address: { + items: { + $ref: '#/components/schemas/Address', + }, + type: 'array', + xml: { + name: 'addresses', + wrapped: true, + }, + }, + id: { + example: 100000, + format: 'int64', + type: 'integer', + }, + username: { + example: 'fehguy', + type: 'string', + }, + }, + type: 'object', + xml: { + name: 'customer', + }, +} as const; + +export const $Address = { + properties: { + city: { + example: 'Palo Alto', + type: 'string', + }, + state: { + example: 'CA', + type: 'string', + }, + street: { + example: '437 Lytton', + type: 'string', + }, + zip: { + example: 94301, + type: 'string', + }, + }, + type: 'object', + xml: { + name: 'address', + }, +} as const; + +export const $Category = { + properties: { + id: { + example: 1, + format: 'int64', + type: 'integer', + }, + name: { + example: 'Dogs', + type: 'string', + }, + }, + type: 'object', + 'x-swagger-router-model': 'io.swagger.petstore.model.Category', + xml: { + name: 'category', + }, +} as const; + +export const $User = { + properties: { + email: { + example: 'john@email.com', + type: 'string', + }, + firstName: { + example: 'John', + type: 'string', + }, + id: { + example: 10, + format: 'int64', + type: 'integer', + }, + lastName: { + example: 'James', + type: 'string', + }, + password: { + example: 12345, + type: 'string', + }, + phone: { + example: 12345, + type: 'string', + }, + userStatus: { + description: 'User Status', + example: 1, + format: 'int32', + type: 'integer', + }, + username: { + example: 'theUser', + type: 'string', + }, + }, + type: 'object', + 'x-swagger-router-model': 'io.swagger.petstore.model.User', + xml: { + name: 'user', + }, +} as const; + +export const $Tag = { + properties: { + id: { + format: 'int64', + type: 'integer', + }, + name: { + type: 'string', + }, + }, + type: 'object', + 'x-swagger-router-model': 'io.swagger.petstore.model.Tag', + xml: { + name: 'tag', + }, +} as const; + +export const $Pet = { + properties: { + category: { + $ref: '#/components/schemas/Category', + }, + id: { + example: 10, + format: 'int64', + type: 'integer', + }, + name: { + example: 'doggie', + type: 'string', + }, + photoUrls: { + items: { + type: 'string', + xml: { + name: 'photoUrl', + }, + }, + type: 'array', + xml: { + wrapped: true, + }, + }, + status: { + description: 'pet status in the store', + enum: ['available', 'pending', 'sold'], + type: 'string', + }, + tags: { + items: { + $ref: '#/components/schemas/Tag', + xml: { + name: 'tag', + }, + }, + type: 'array', + xml: { + wrapped: true, + }, + }, + }, + required: ['name', 'photoUrls'], + type: 'object', + 'x-swagger-router-model': 'io.swagger.petstore.model.Pet', + xml: { + name: 'pet', + }, +} as const; + +export const $ApiResponse = { + properties: { + code: { + format: 'int32', + type: 'integer', + }, + message: { + type: 'string', + }, + type: { + type: 'string', + }, + }, + type: 'object', + xml: { + name: '##default', + }, +} as const; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/client/services.gen.ts b/examples/openapi-ts-tanstack-svelte-query/src/client/services.gen.ts new file mode 100644 index 000000000..d495ca284 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/client/services.gen.ts @@ -0,0 +1,337 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { + createClient, + createConfig, + type Options, +} from '@hey-api/client-fetch'; + +import type { + AddPetData, + AddPetError, + AddPetResponse, + CreateUserData, + CreateUserError, + CreateUserResponse, + CreateUsersWithListInputData, + CreateUsersWithListInputError, + CreateUsersWithListInputResponse, + DeleteOrderData, + DeletePetData, + DeleteUserData, + FindPetsByStatusData, + FindPetsByStatusError, + FindPetsByStatusResponse, + FindPetsByTagsData, + FindPetsByTagsError, + FindPetsByTagsResponse, + GetInventoryError, + GetInventoryResponse, + GetOrderByIdData, + GetOrderByIdError, + GetOrderByIdResponse, + GetPetByIdData, + GetPetByIdError, + GetPetByIdResponse, + GetUserByNameData, + GetUserByNameError, + GetUserByNameResponse, + LoginUserData, + LoginUserError, + LoginUserResponse, + LogoutUserError, + LogoutUserResponse, + PlaceOrderData, + PlaceOrderError, + PlaceOrderResponse, + UpdatePetData, + UpdatePetError, + UpdatePetResponse, + UpdatePetWithFormData, + UpdateUserData, + UpdateUserError, + UpdateUserResponse, + UploadFileData, + UploadFileError, + UploadFileResponse, +} from './types.gen'; + +export const client = createClient(createConfig()); + +/** + * Add a new pet to the store + * Add a new pet to the store + */ +export const addPet = ( + options: Options, +) => + (options?.client ?? client).post({ + ...options, + url: '/pet', + }); + +/** + * Update an existing pet + * Update an existing pet by Id + */ +export const updatePet = ( + options: Options, +) => + (options?.client ?? client).put< + UpdatePetResponse, + UpdatePetError, + ThrowOnError + >({ + ...options, + url: '/pet', + }); + +/** + * Finds Pets by status + * Multiple status values can be provided with comma separated strings + */ +export const findPetsByStatus = ( + options?: Options, +) => + (options?.client ?? client).get< + FindPetsByStatusResponse, + FindPetsByStatusError, + ThrowOnError + >({ + ...options, + url: '/pet/findByStatus', + }); + +/** + * Finds Pets by tags + * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. + */ +export const findPetsByTags = ( + options?: Options, +) => + (options?.client ?? client).get< + FindPetsByTagsResponse, + FindPetsByTagsError, + ThrowOnError + >({ + ...options, + url: '/pet/findByTags', + }); + +/** + * Find pet by ID + * Returns a single pet + */ +export const getPetById = ( + options: Options, +) => + (options?.client ?? client).get< + GetPetByIdResponse, + GetPetByIdError, + ThrowOnError + >({ + ...options, + url: '/pet/{petId}', + }); + +/** + * Updates a pet in the store with form data + */ +export const updatePetWithForm = ( + options: Options, +) => + (options?.client ?? client).post({ + ...options, + url: '/pet/{petId}', + }); + +/** + * Deletes a pet + */ +export const deletePet = ( + options: Options, +) => + (options?.client ?? client).delete({ + ...options, + url: '/pet/{petId}', + }); + +/** + * uploads an image + */ +export const uploadFile = ( + options: Options, +) => + (options?.client ?? client).post< + UploadFileResponse, + UploadFileError, + ThrowOnError + >({ + ...options, + url: '/pet/{petId}/uploadImage', + }); + +/** + * Returns pet inventories by status + * Returns a map of status codes to quantities + */ +export const getInventory = ( + options?: Options, +) => + (options?.client ?? client).get< + GetInventoryResponse, + GetInventoryError, + ThrowOnError + >({ + ...options, + url: '/store/inventory', + }); + +/** + * Place an order for a pet + * Place a new order in the store + */ +export const placeOrder = ( + options?: Options, +) => + (options?.client ?? client).post< + PlaceOrderResponse, + PlaceOrderError, + ThrowOnError + >({ + ...options, + url: '/store/order', + }); + +/** + * Find purchase order by ID + * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions. + */ +export const getOrderById = ( + options: Options, +) => + (options?.client ?? client).get< + GetOrderByIdResponse, + GetOrderByIdError, + ThrowOnError + >({ + ...options, + url: '/store/order/{orderId}', + }); + +/** + * Delete purchase order by ID + * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors + */ +export const deleteOrder = ( + options: Options, +) => + (options?.client ?? client).delete({ + ...options, + url: '/store/order/{orderId}', + }); + +/** + * Create user + * This can only be done by the logged in user. + */ +export const createUser = ( + options?: Options, +) => + (options?.client ?? client).post< + CreateUserResponse, + CreateUserError, + ThrowOnError + >({ + ...options, + url: '/user', + }); + +/** + * Creates list of users with given input array + * Creates list of users with given input array + */ +export const createUsersWithListInput = ( + options?: Options, +) => + (options?.client ?? client).post< + CreateUsersWithListInputResponse, + CreateUsersWithListInputError, + ThrowOnError + >({ + ...options, + url: '/user/createWithList', + }); + +/** + * Logs user into the system + */ +export const loginUser = ( + options?: Options, +) => + (options?.client ?? client).get< + LoginUserResponse, + LoginUserError, + ThrowOnError + >({ + ...options, + url: '/user/login', + }); + +/** + * Logs out current logged in user session + */ +export const logoutUser = ( + options?: Options, +) => + (options?.client ?? client).get< + LogoutUserResponse, + LogoutUserError, + ThrowOnError + >({ + ...options, + url: '/user/logout', + }); + +/** + * Get user by user name + */ +export const getUserByName = ( + options: Options, +) => + (options?.client ?? client).get< + GetUserByNameResponse, + GetUserByNameError, + ThrowOnError + >({ + ...options, + url: '/user/{username}', + }); + +/** + * Update user + * This can only be done by the logged in user. + */ +export const updateUser = ( + options: Options, +) => + (options?.client ?? client).put< + UpdateUserResponse, + UpdateUserError, + ThrowOnError + >({ + ...options, + url: '/user/{username}', + }); + +/** + * Delete user + * This can only be done by the logged in user. + */ +export const deleteUser = ( + options: Options, +) => + (options?.client ?? client).delete({ + ...options, + url: '/user/{username}', + }); diff --git a/examples/openapi-ts-tanstack-svelte-query/src/client/types.gen.ts b/examples/openapi-ts-tanstack-svelte-query/src/client/types.gen.ts new file mode 100644 index 000000000..9dbad3c84 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/client/types.gen.ts @@ -0,0 +1,323 @@ +// This file is auto-generated by @hey-api/openapi-ts + +export type Order = { + complete?: boolean; + id?: number; + petId?: number; + quantity?: number; + shipDate?: string; + /** + * Order Status + */ + status?: 'placed' | 'approved' | 'delivered'; +}; + +/** + * Order Status + */ +export type status = 'placed' | 'approved' | 'delivered'; + +/** + * Order Status + */ +export const status = { + APPROVED: 'approved', + DELIVERED: 'delivered', + PLACED: 'placed', +} as const; + +export type Customer = { + address?: Array
; + id?: number; + username?: string; +}; + +export type Address = { + city?: string; + state?: string; + street?: string; + zip?: string; +}; + +export type Category = { + id?: number; + name?: string; +}; + +export type User = { + email?: string; + firstName?: string; + id?: number; + lastName?: string; + password?: string; + phone?: string; + /** + * User Status + */ + userStatus?: number; + username?: string; +}; + +export type Tag = { + id?: number; + name?: string; +}; + +export type Pet = { + category?: Category; + id?: number; + name: string; + photoUrls: Array; + /** + * pet status in the store + */ + status?: 'available' | 'pending' | 'sold'; + tags?: Array; +}; + +/** + * pet status in the store + */ +export type status2 = 'available' | 'pending' | 'sold'; + +/** + * pet status in the store + */ +export const status2 = { + AVAILABLE: 'available', + PENDING: 'pending', + SOLD: 'sold', +} as const; + +export type ApiResponse = { + code?: number; + message?: string; + type?: string; +}; + +export type AddPetData = { + /** + * Create a new pet in the store + */ + body: Pet; +}; + +export type AddPetResponse = Pet; + +export type AddPetError = unknown; + +export type UpdatePetData = { + /** + * Update an existent pet in the store + */ + body: Pet; +}; + +export type UpdatePetResponse = Pet; + +export type UpdatePetError = unknown; + +export type FindPetsByStatusData = { + query?: { + /** + * Status values that need to be considered for filter + */ + status?: 'available' | 'pending' | 'sold'; + }; +}; + +export type FindPetsByStatusResponse = Array; + +export type FindPetsByStatusError = unknown; + +export type FindPetsByTagsData = { + query?: { + /** + * Tags to filter by + */ + tags?: Array; + }; +}; + +export type FindPetsByTagsResponse = Array; + +export type FindPetsByTagsError = unknown; + +export type GetPetByIdData = { + path: { + /** + * ID of pet to return + */ + petId: number; + }; +}; + +export type GetPetByIdResponse = Pet; + +export type GetPetByIdError = unknown; + +export type UpdatePetWithFormData = { + path: { + /** + * ID of pet that needs to be updated + */ + petId: number; + }; + query?: { + /** + * Name of pet that needs to be updated + */ + name?: string; + /** + * Status of pet that needs to be updated + */ + status?: string; + }; +}; + +export type DeletePetData = { + headers?: { + api_key?: string; + }; + path: { + /** + * Pet id to delete + */ + petId: number; + }; +}; + +export type UploadFileData = { + body?: Blob | File; + path: { + /** + * ID of pet to update + */ + petId: number; + }; + query?: { + /** + * Additional Metadata + */ + additionalMetadata?: string; + }; +}; + +export type UploadFileResponse = ApiResponse; + +export type UploadFileError = unknown; + +export type GetInventoryResponse = { + [key: string]: number; +}; + +export type GetInventoryError = unknown; + +export type PlaceOrderData = { + body?: Order; +}; + +export type PlaceOrderResponse = Order; + +export type PlaceOrderError = unknown; + +export type GetOrderByIdData = { + path: { + /** + * ID of order that needs to be fetched + */ + orderId: number; + }; +}; + +export type GetOrderByIdResponse = Order; + +export type GetOrderByIdError = unknown; + +export type DeleteOrderData = { + path: { + /** + * ID of the order that needs to be deleted + */ + orderId: number; + }; +}; + +export type CreateUserData = { + /** + * Created user object + */ + body?: User; +}; + +export type CreateUserResponse = User; + +export type CreateUserError = unknown; + +export type CreateUsersWithListInputData = { + body?: Array; +}; + +export type CreateUsersWithListInputResponse = User | unknown; + +export type CreateUsersWithListInputError = unknown; + +export type LoginUserData = { + query?: { + /** + * The password for login in clear text + */ + password?: string; + /** + * The user name for login + */ + username?: string; + }; +}; + +export type LoginUserResponse = string; + +export type LoginUserError = unknown; + +export type LogoutUserResponse = unknown; + +export type LogoutUserError = unknown; + +export type GetUserByNameData = { + path: { + /** + * The name that needs to be fetched. Use user1 for testing. + */ + username: string; + }; +}; + +export type GetUserByNameResponse = User; + +export type GetUserByNameError = unknown; + +export type UpdateUserData = { + /** + * Update an existent user in the store + */ + body?: User; + path: { + /** + * name that needs to be updated + */ + username: string; + }; +}; + +export type UpdateUserResponse = unknown; + +export type UpdateUserError = unknown; + +export type DeleteUserData = { + path: { + /** + * The name that needs to be deleted + */ + username: string; + }; +}; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/lib/images/github.svg b/examples/openapi-ts-tanstack-svelte-query/src/lib/images/github.svg new file mode 100644 index 000000000..bc5d249d3 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/lib/images/github.svg @@ -0,0 +1,16 @@ + + + + \ No newline at end of file diff --git a/examples/openapi-ts-tanstack-svelte-query/src/lib/images/svelte-logo.svg b/examples/openapi-ts-tanstack-svelte-query/src/lib/images/svelte-logo.svg new file mode 100644 index 000000000..49492a83c --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/lib/images/svelte-logo.svg @@ -0,0 +1 @@ +svelte-logo \ No newline at end of file diff --git a/examples/openapi-ts-tanstack-svelte-query/src/lib/images/svelte-welcome.png b/examples/openapi-ts-tanstack-svelte-query/src/lib/images/svelte-welcome.png new file mode 100644 index 0000000000000000000000000000000000000000..fe7d2d6b50ce937a0c3cecaa9a3501dfe138b7c8 GIT binary patch literal 360807 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

oR`Gssd_-Ce^ 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�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¥dbdjblhpM_|E}(+ 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
+
+ +
+ + + +
+ + +
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.svelte new file mode 100644 index 000000000..3558177b1 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.svelte @@ -0,0 +1,97 @@ + + + + Home + + + +
+

+ + + + Welcome + + + + to your new
SvelteKit app +

+ + {#if $query.isPending} + Loading... + {/if} + {#if $query.error} + Error... + {/if} + {#if $query.isSuccess} + {$query.data.name} + {/if} + + +

+ try editing src/routes/+page.svelte +

+ + +
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.ts new file mode 100644 index 000000000..a72419a63 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/+page.ts @@ -0,0 +1,3 @@ +// since there's no dynamic data here, we can prerender +// it so that it gets served as a static asset in production +export const prerender = true; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/Counter.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/Counter.svelte new file mode 100644 index 000000000..96ef556d3 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/Counter.svelte @@ -0,0 +1,102 @@ + + +
+ + +
+
+ + {Math.floor($displayed_count)} +
+
+ + +
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/Header.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/Header.svelte new file mode 100644 index 000000000..368b721e8 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/Header.svelte @@ -0,0 +1,129 @@ + + +
+
+ + SvelteKit + +
+ + + +
+ + GitHub + +
+
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.svelte new file mode 100644 index 000000000..7f7946d23 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.svelte @@ -0,0 +1,26 @@ + + About + + + +
+

About this app

+ +

+ This is a SvelteKit app. You can make your own by typing the + following into your command line and following the prompts: +

+ + 
npm create svelte@latest
+ +

+ The page you're looking at is purely static HTML, with no client-side interactivity needed. + Because of that, we don't need to load any JavaScript. Try viewing the page's source, or opening + the devtools network panel and reloading. +

+ +

+ The Sverdle page illustrates SvelteKit's data loading and form handling. Try + using it with JavaScript disabled! +

+
diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.ts new file mode 100644 index 000000000..e739ef4b6 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/about/+page.ts @@ -0,0 +1,9 @@ +import { dev } from '$app/environment'; + +// we don't need any JS on this page, though we'll load +// it in dev so that we get hot module replacement +export const csr = dev; + +// since there's no dynamic data here, we can prerender +// it so that it gets served as a static asset in production +export const prerender = true; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.server.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.server.ts new file mode 100644 index 000000000..bb0ec26a1 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.server.ts @@ -0,0 +1,70 @@ +import { fail } from '@sveltejs/kit'; + +import type { Actions, PageServerLoad } from './$types'; +import { Game } from './game'; + +export const load = (({ cookies }) => { + const game = new Game(cookies.get('sverdle')); + + return { + /** + * The correct answer, revealed if the game is over + */ + answer: game.answers.length >= 6 ? game.answer : null, + + /** + * An array of strings like '__x_c' corresponding to the guesses, where 'x' means + * an exact match, and 'c' means a close match (right letter, wrong place) + */ + answers: game.answers, + + /** + * The player's guessed words so far + */ + guesses: game.guesses, + }; +}) satisfies PageServerLoad; + +export const actions = { + /** + * Modify game state in reaction to a guessed word. This logic always runs on + * the server, so that people can't cheat by peeking at the JavaScript + */ + enter: async ({ request, cookies }) => { + const game = new Game(cookies.get('sverdle')); + + const data = await request.formData(); + const guess = data.getAll('guess') as string[]; + + if (!game.enter(guess)) { + return fail(400, { badGuess: true }); + } + + cookies.set('sverdle', game.toString(), { path: '/' }); + }, + + restart: async ({ cookies }) => { + cookies.delete('sverdle', { path: '/' }); + }, + + /** + * Modify game state in reaction to a keypress. If client-side JavaScript + * is available, this will happen in the browser instead of here + */ + update: async ({ request, cookies }) => { + const game = new Game(cookies.get('sverdle')); + + const data = await request.formData(); + const key = data.get('key'); + + const i = game.answers.length; + + if (key === 'backspace') { + game.guesses[i] = game.guesses[i].slice(0, -1); + } else { + game.guesses[i] += key; + } + + cookies.set('sverdle', game.toString(), { path: '/' }); + }, +} satisfies Actions; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.svelte new file mode 100644 index 000000000..6fa441809 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/+page.svelte @@ -0,0 +1,409 @@ + + + + + + Sverdle + + + +

Sverdle

+ +
{ + // prevent default callback from resetting the form + return ({ update }) => { + update({ reset: false }); + }; + }} +> + How to play + +
+ {#each Array.from(Array(6).keys()) as row (row)} + {@const current = row === i} + +
+ {#each Array.from(Array(5).keys()) as column (column)} + {@const guess = current ? currentGuess : data.guesses[row]} + {@const answer = data.answers[row]?.[column]} + {@const value = guess?.[column] ?? ''} + {@const selected = current && column === guess.length} + {@const exact = answer === 'x'} + {@const close = answer === 'c'} + {@const missing = answer === '_'} +
+ {value} + + +
+ {/each} +
+ {/each} +
+ +
+ {#if won || data.answers.length >= 6} + {#if !won && data.answer} +

the answer was "{data.answer}"

+ {/if} + + {:else} +
+ + + + + {#each ['qwertyuiop', 'asdfghjkl', 'zxcvbnm'] as row} +
+ {#each row as letter} + + {/each} +
+ {/each} +
+ {/if} +
+
+ +{#if won} +
+{/if} + + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.test.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.test.ts new file mode 100644 index 000000000..5b68855f9 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.test.ts @@ -0,0 +1,10 @@ +import { describe, expect, it } from 'vitest'; + +import { Game } from './game'; + +describe('game test', () => { + it('returns true when a valid word is entered', () => { + const game = new Game(); + expect(game.enter('zorro'.split(''))).toBe(true); + }); +}); diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.ts new file mode 100644 index 000000000..468bdddcc --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/game.ts @@ -0,0 +1,75 @@ +import { allowed, words } from './words.server'; + +export class Game { + index: number; + guesses: string[]; + answers: string[]; + answer: string; + + /** + * Create a game object from the player's cookie, or initialise a new game + */ + constructor(serialized: string | undefined = undefined) { + if (serialized) { + const [index, guesses, answers] = serialized.split('-'); + + this.index = +index; + this.guesses = guesses ? guesses.split(' ') : []; + this.answers = answers ? answers.split(' ') : []; + } else { + this.index = Math.floor(Math.random() * words.length); + this.guesses = ['', '', '', '', '', '']; + this.answers = []; + } + + this.answer = words[this.index]; + } + + /** + * Update game state based on a guess of a five-letter word. Returns + * true if the guess was valid, false otherwise + */ + enter(letters: string[]) { + const word = letters.join(''); + const valid = allowed.has(word); + + if (!valid) return false; + + this.guesses[this.answers.length] = word; + + const available = Array.from(this.answer); + const answer = Array(5).fill('_'); + + // first, find exact matches + for (let i = 0; i < 5; i += 1) { + if (letters[i] === available[i]) { + answer[i] = 'x'; + available[i] = ' '; + } + } + + // then find close matches (this has to happen + // in a second step, otherwise an early close + // match can prevent a later exact match) + for (let i = 0; i < 5; i += 1) { + if (answer[i] === '_') { + const index = available.indexOf(letters[i]); + if (index !== -1) { + answer[i] = 'c'; + available[index] = ' '; + } + } + } + + this.answers.push(answer.join('')); + + return true; + } + + /** + * Serialize game state so it can be set as a cookie + */ + toString() { + return `${this.index}-${this.guesses.join(' ')}-${this.answers.join(' ')}`; + } +} diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.svelte new file mode 100644 index 000000000..e8e2cec31 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.svelte @@ -0,0 +1,95 @@ + + How to play Sverdle + + + +
+

How to play Sverdle

+ +

+ Sverdle is a clone of Wordle, the + word guessing game. To play, enter a five-letter English word. For example: +

+ +
+ r + i + t + z + y +
+ +

+ The y is in the right place. r and + t + are the right letters, but in the wrong place. The other letters are wrong, and can be discarded. + Let's make another guess: +

+ +
+ p + a + r + t + y +
+ +

This time we guessed right! You have six guesses to get the word.

+ +

+ Unlike the original Wordle, Sverdle runs on the server instead of in the browser, making it + impossible to cheat. It uses <form> and cookies to submit data, meaning you can + even play with JavaScript disabled! +

+
+ + diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.ts new file mode 100644 index 000000000..e739ef4b6 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/how-to-play/+page.ts @@ -0,0 +1,9 @@ +import { dev } from '$app/environment'; + +// we don't need any JS on this page, though we'll load +// it in dev so that we get hot module replacement +export const csr = dev; + +// since there's no dynamic data here, we can prerender +// it so that it gets served as a static asset in production +export const prerender = true; diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/reduced-motion.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/reduced-motion.ts new file mode 100644 index 000000000..693c981de --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/reduced-motion.ts @@ -0,0 +1,27 @@ +import { readable } from 'svelte/store'; + +import { browser } from '$app/environment'; + +const reduced_motion_query = '(prefers-reduced-motion: reduce)'; + +const get_initial_motion_preference = () => { + if (!browser) return false; + return window.matchMedia(reduced_motion_query).matches; +}; + +export const reduced_motion = readable( + get_initial_motion_preference(), + (set) => { + if (browser) { + const set_reduced_motion = (event: MediaQueryListEvent) => { + set(event.matches); + }; + const media_query_list = window.matchMedia(reduced_motion_query); + media_query_list.addEventListener('change', set_reduced_motion); + + return () => { + media_query_list.removeEventListener('change', set_reduced_motion); + }; + } + }, +); diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/words.server.ts b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/words.server.ts new file mode 100644 index 000000000..806c0ad7d --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/sverdle/words.server.ts @@ -0,0 +1,12980 @@ +/** The list of possible words */ +export const words = [ + 'aback', + 'abase', + 'abate', + 'abbey', + 'abbot', + 'abhor', + 'abide', + 'abled', + 'abode', + 'abort', + 'about', + 'above', + 'abuse', + 'abyss', + 'acorn', + 'acrid', + 'actor', + 'acute', + 'adage', + 'adapt', + 'adept', + 'admin', + 'admit', + 'adobe', + 'adopt', + 'adore', + 'adorn', + 'adult', + 'affix', + 'afire', + 'afoot', + 'afoul', + 'after', + 'again', + 'agape', + 'agate', + 'agent', + 'agile', + 'aging', + 'aglow', + 'agony', + 'agora', + 'agree', + 'ahead', + 'aider', + 'aisle', + 'alarm', + 'album', + 'alert', + 'algae', + 'alibi', + 'alien', + 'align', + 'alike', + 'alive', + 'allay', + 'alley', + 'allot', + 'allow', + 'alloy', + 'aloft', + 'alone', + 'along', + 'aloof', + 'aloud', + 'alpha', + 'altar', + 'alter', + 'amass', + 'amaze', + 'amber', + 'amble', + 'amend', + 'amiss', + 'amity', + 'among', + 'ample', + 'amply', + 'amuse', + 'angel', + 'anger', + 'angle', + 'angry', + 'angst', + 'anime', + 'ankle', + 'annex', + 'annoy', + 'annul', + 'anode', + 'antic', + 'anvil', + 'aorta', + 'apart', + 'aphid', + 'aping', + 'apnea', + 'apple', + 'apply', + 'apron', + 'aptly', + 'arbor', + 'ardor', + 'arena', + 'argue', + 'arise', + 'armor', + 'aroma', + 'arose', + 'array', + 'arrow', + 'arson', + 'artsy', + 'ascot', + 'ashen', + 'aside', + 'askew', + 'assay', + 'asset', + 'atoll', + 'atone', + 'attic', + 'audio', + 'audit', + 'augur', + 'aunty', + 'avail', + 'avert', + 'avian', + 'avoid', + 'await', + 'awake', + 'award', + 'aware', + 'awash', + 'awful', + 'awoke', + 'axial', + 'axiom', + 'axion', + 'azure', + 'bacon', + 'badge', + 'badly', + 'bagel', + 'baggy', + 'baker', + 'baler', + 'balmy', + 'banal', + 'banjo', + 'barge', + 'baron', + 'basal', + 'basic', + 'basil', + 'basin', + 'basis', + 'baste', + 'batch', + 'bathe', + 'baton', + 'batty', + 'bawdy', + 'bayou', + 'beach', + 'beady', + 'beard', + 'beast', + 'beech', + 'beefy', + 'befit', + 'began', + 'begat', + 'beget', + 'begin', + 'begun', + 'being', + 'belch', + 'belie', + 'belle', + 'belly', + 'below', + 'bench', + 'beret', + 'berry', + 'berth', + 'beset', + 'betel', + 'bevel', + 'bezel', + 'bible', + 'bicep', + 'biddy', + 'bigot', + 'bilge', + 'billy', + 'binge', + 'bingo', + 'biome', + 'birch', + 'birth', + 'bison', + 'bitty', + 'black', + 'blade', + 'blame', + 'bland', + 'blank', + 'blare', + 'blast', + 'blaze', + 'bleak', + 'bleat', + 'bleed', + 'bleep', + 'blend', + 'bless', + 'blimp', + 'blind', + 'blink', + 'bliss', + 'blitz', + 'bloat', + 'block', + 'bloke', + 'blond', + 'blood', + 'bloom', + 'blown', + 'bluer', + 'bluff', + 'blunt', + 'blurb', + 'blurt', + 'blush', + 'board', + 'boast', + 'bobby', + 'boney', + 'bongo', + 'bonus', + 'booby', + 'boost', + 'booth', + 'booty', + 'booze', + 'boozy', + 'borax', + 'borne', + 'bosom', + 'bossy', + 'botch', + 'bough', + 'boule', + 'bound', + 'bowel', + 'boxer', + 'brace', + 'braid', + 'brain', + 'brake', + 'brand', + 'brash', + 'brass', + 'brave', + 'bravo', + 'brawl', + 'brawn', + 'bread', + 'break', + 'breed', + 'briar', + 'bribe', + 'brick', + 'bride', + 'brief', + 'brine', + 'bring', + 'brink', + 'briny', + 'brisk', + 'broad', + 'broil', + 'broke', + 'brood', + 'brook', + 'broom', + 'broth', + 'brown', + 'brunt', + 'brush', + 'brute', + 'buddy', + 'budge', + 'buggy', + 'bugle', + 'build', + 'built', + 'bulge', + 'bulky', + 'bully', + 'bunch', + 'bunny', + 'burly', + 'burnt', + 'burst', + 'bused', + 'bushy', + 'butch', + 'butte', + 'buxom', + 'buyer', + 'bylaw', + 'cabal', + 'cabby', + 'cabin', + 'cable', + 'cacao', + 'cache', + 'cacti', + 'caddy', + 'cadet', + 'cagey', + 'cairn', + 'camel', + 'cameo', + 'canal', + 'candy', + 'canny', + 'canoe', + 'canon', + 'caper', + 'caput', + 'carat', + 'cargo', + 'carol', + 'carry', + 'carve', + 'caste', + 'catch', + 'cater', + 'catty', + 'caulk', + 'cause', + 'cavil', + 'cease', + 'cedar', + 'cello', + 'chafe', + 'chaff', + 'chain', + 'chair', + 'chalk', + 'champ', + 'chant', + 'chaos', + 'chard', + 'charm', + 'chart', + 'chase', + 'chasm', + 'cheap', + 'cheat', + 'check', + 'cheek', + 'cheer', + 'chess', + 'chest', + 'chick', + 'chide', + 'chief', + 'child', + 'chili', + 'chill', + 'chime', + 'china', + 'chirp', + 'chock', + 'choir', + 'choke', + 'chord', + 'chore', + 'chose', + 'chuck', + 'chump', + 'chunk', + 'churn', + 'chute', + 'cider', + 'cigar', + 'cinch', + 'circa', + 'civic', + 'civil', + 'clack', + 'claim', + 'clamp', + 'clang', + 'clank', + 'clash', + 'clasp', + 'class', + 'clean', + 'clear', + 'cleat', + 'cleft', + 'clerk', + 'click', + 'cliff', + 'climb', + 'cling', + 'clink', + 'cloak', + 'clock', + 'clone', + 'close', + 'cloth', + 'cloud', + 'clout', + 'clove', + 'clown', + 'cluck', + 'clued', + 'clump', + 'clung', + 'coach', + 'coast', + 'cobra', + 'cocoa', + 'colon', + 'color', + 'comet', + 'comfy', + 'comic', + 'comma', + 'conch', + 'condo', + 'conic', + 'copse', + 'coral', + 'corer', + 'corny', + 'couch', + 'cough', + 'could', + 'count', + 'coupe', + 'court', + 'coven', + 'cover', + 'covet', + 'covey', + 'cower', + 'coyly', + 'crack', + 'craft', + 'cramp', + 'crane', + 'crank', + 'crash', + 'crass', + 'crate', + 'crave', + 'crawl', + 'craze', + 'crazy', + 'creak', + 'cream', + 'credo', + 'creed', + 'creek', + 'creep', + 'creme', + 'crepe', + 'crept', + 'cress', + 'crest', + 'crick', + 'cried', + 'crier', + 'crime', + 'crimp', + 'crisp', + 'croak', + 'crock', + 'crone', + 'crony', + 'crook', + 'cross', + 'croup', + 'crowd', + 'crown', + 'crude', + 'cruel', + 'crumb', + 'crump', + 'crush', + 'crust', + 'crypt', + 'cubic', + 'cumin', + 'curio', + 'curly', + 'curry', + 'curse', + 'curve', + 'curvy', + 'cutie', + 'cyber', + 'cycle', + 'cynic', + 'daddy', + 'daily', + 'dairy', + 'daisy', + 'dally', + 'dance', + 'dandy', + 'datum', + 'daunt', + 'dealt', + 'death', + 'debar', + 'debit', + 'debug', + 'debut', + 'decal', + 'decay', + 'decor', + 'decoy', + 'decry', + 'defer', + 'deign', + 'deity', + 'delay', + 'delta', + 'delve', + 'demon', + 'demur', + 'denim', + 'dense', + 'depot', + 'depth', + 'derby', + 'deter', + 'detox', + 'deuce', + 'devil', + 'diary', + 'dicey', + 'digit', + 'dilly', + 'dimly', + 'diner', + 'dingo', + 'dingy', + 'diode', + 'dirge', + 'dirty', + 'disco', + 'ditch', + 'ditto', + 'ditty', + 'diver', + 'dizzy', + 'dodge', + 'dodgy', + 'dogma', + 'doing', + 'dolly', + 'donor', + 'donut', + 'dopey', + 'doubt', + 'dough', + 'dowdy', + 'dowel', + 'downy', + 'dowry', + 'dozen', + 'draft', + 'drain', + 'drake', + 'drama', + 'drank', + 'drape', + 'drawl', + 'drawn', + 'dread', + 'dream', + 'dress', + 'dried', + 'drier', + 'drift', + 'drill', + 'drink', + 'drive', + 'droit', + 'droll', + 'drone', + 'drool', + 'droop', + 'dross', + 'drove', + 'drown', + 'druid', + 'drunk', + 'dryer', + 'dryly', + 'duchy', + 'dully', + 'dummy', + 'dumpy', + 'dunce', + 'dusky', + 'dusty', + 'dutch', + 'duvet', + 'dwarf', + 'dwell', + 'dwelt', + 'dying', + 'eager', + 'eagle', + 'early', + 'earth', + 'easel', + 'eaten', + 'eater', + 'ebony', + 'eclat', + 'edict', + 'edify', + 'eerie', + 'egret', + 'eight', + 'eject', + 'eking', + 'elate', + 'elbow', + 'elder', + 'elect', + 'elegy', + 'elfin', + 'elide', + 'elite', + 'elope', + 'elude', + 'email', + 'embed', + 'ember', + 'emcee', + 'empty', + 'enact', + 'endow', + 'enema', + 'enemy', + 'enjoy', + 'ennui', + 'ensue', + 'enter', + 'entry', + 'envoy', + 'epoch', + 'epoxy', + 'equal', + 'equip', + 'erase', + 'erect', + 'erode', + 'error', + 'erupt', + 'essay', + 'ester', + 'ether', + 'ethic', + 'ethos', + 'etude', + 'evade', + 'event', + 'every', + 'evict', + 'evoke', + 'exact', + 'exalt', + 'excel', + 'exert', + 'exile', + 'exist', + 'expel', + 'extol', + 'extra', + 'exult', + 'eying', + 'fable', + 'facet', + 'faint', + 'fairy', + 'faith', + 'false', + 'fancy', + 'fanny', + 'farce', + 'fatal', + 'fatty', + 'fault', + 'fauna', + 'favor', + 'feast', + 'fecal', + 'feign', + 'fella', + 'felon', + 'femme', + 'femur', + 'fence', + 'feral', + 'ferry', + 'fetal', + 'fetch', + 'fetid', + 'fetus', + 'fever', + 'fewer', + 'fiber', + 'fibre', + 'ficus', + 'field', + 'fiend', + 'fiery', + 'fifth', + 'fifty', + 'fight', + 'filer', + 'filet', + 'filly', + 'filmy', + 'filth', + 'final', + 'finch', + 'finer', + 'first', + 'fishy', + 'fixer', + 'fizzy', + 'fjord', + 'flack', + 'flail', + 'flair', + 'flake', + 'flaky', + 'flame', + 'flank', + 'flare', + 'flash', + 'flask', + 'fleck', + 'fleet', + 'flesh', + 'flick', + 'flier', + 'fling', + 'flint', + 'flirt', + 'float', + 'flock', + 'flood', + 'floor', + 'flora', + 'floss', + 'flour', + 'flout', + 'flown', + 'fluff', + 'fluid', + 'fluke', + 'flume', + 'flung', + 'flunk', + 'flush', + 'flute', + 'flyer', + 'foamy', + 'focal', + 'focus', + 'foggy', + 'foist', + 'folio', + 'folly', + 'foray', + 'force', + 'forge', + 'forgo', + 'forte', + 'forth', + 'forty', + 'forum', + 'found', + 'foyer', + 'frail', + 'frame', + 'frank', + 'fraud', + 'freak', + 'freed', + 'freer', + 'fresh', + 'friar', + 'fried', + 'frill', + 'frisk', + 'fritz', + 'frock', + 'frond', + 'front', + 'frost', + 'froth', + 'frown', + 'froze', + 'fruit', + 'fudge', + 'fugue', + 'fully', + 'fungi', + 'funky', + 'funny', + 'furor', + 'furry', + 'fussy', + 'fuzzy', + 'gaffe', + 'gaily', + 'gamer', + 'gamma', + 'gamut', + 'gassy', + 'gaudy', + 'gauge', + 'gaunt', + 'gauze', + 'gavel', + 'gawky', + 'gayer', + 'gayly', + 'gazer', + 'gecko', + 'geeky', + 'geese', + 'genie', + 'genre', + 'ghost', + 'ghoul', + 'giant', + 'giddy', + 'gipsy', + 'girly', + 'girth', + 'given', + 'giver', + 'glade', + 'gland', + 'glare', + 'glass', + 'glaze', + 'gleam', + 'glean', + 'glide', + 'glint', + 'gloat', + 'globe', + 'gloom', + 'glory', + 'gloss', + 'glove', + 'glyph', + 'gnash', + 'gnome', + 'godly', + 'going', + 'golem', + 'golly', + 'gonad', + 'goner', + 'goody', + 'gooey', + 'goofy', + 'goose', + 'gorge', + 'gouge', + 'gourd', + 'grace', + 'grade', + 'graft', + 'grail', + 'grain', + 'grand', + 'grant', + 'grape', + 'graph', + 'grasp', + 'grass', + 'grate', + 'grave', + 'gravy', + 'graze', + 'great', + 'greed', + 'green', + 'greet', + 'grief', + 'grill', + 'grime', + 'grimy', + 'grind', + 'gripe', + 'groan', + 'groin', + 'groom', + 'grope', + 'gross', + 'group', + 'grout', + 'grove', + 'growl', + 'grown', + 'gruel', + 'gruff', + 'grunt', + 'guard', + 'guava', + 'guess', + 'guest', + 'guide', + 'guild', + 'guile', + 'guilt', + 'guise', + 'gulch', + 'gully', + 'gumbo', + 'gummy', + 'guppy', + 'gusto', + 'gusty', + 'gypsy', + 'habit', + 'hairy', + 'halve', + 'handy', + 'happy', + 'hardy', + 'harem', + 'harpy', + 'harry', + 'harsh', + 'haste', + 'hasty', + 'hatch', + 'hater', + 'haunt', + 'haute', + 'haven', + 'havoc', + 'hazel', + 'heady', + 'heard', + 'heart', + 'heath', + 'heave', + 'heavy', + 'hedge', + 'hefty', + 'heist', + 'helix', + 'hello', + 'hence', + 'heron', + 'hilly', + 'hinge', + 'hippo', + 'hippy', + 'hitch', + 'hoard', + 'hobby', + 'hoist', + 'holly', + 'homer', + 'honey', + 'honor', + 'horde', + 'horny', + 'horse', + 'hotel', + 'hotly', + 'hound', + 'house', + 'hovel', + 'hover', + 'howdy', + 'human', + 'humid', + 'humor', + 'humph', + 'humus', + 'hunch', + 'hunky', + 'hurry', + 'husky', + 'hussy', + 'hutch', + 'hydro', + 'hyena', + 'hymen', + 'hyper', + 'icily', + 'icing', + 'ideal', + 'idiom', + 'idiot', + 'idler', + 'idyll', + 'igloo', + 'iliac', + 'image', + 'imbue', + 'impel', + 'imply', + 'inane', + 'inbox', + 'incur', + 'index', + 'inept', + 'inert', + 'infer', + 'ingot', + 'inlay', + 'inlet', + 'inner', + 'input', + 'inter', + 'intro', + 'ionic', + 'irate', + 'irony', + 'islet', + 'issue', + 'itchy', + 'ivory', + 'jaunt', + 'jazzy', + 'jelly', + 'jerky', + 'jetty', + 'jewel', + 'jiffy', + 'joint', + 'joist', + 'joker', + 'jolly', + 'joust', + 'judge', + 'juice', + 'juicy', + 'jumbo', + 'jumpy', + 'junta', + 'junto', + 'juror', + 'kappa', + 'karma', + 'kayak', + 'kebab', + 'khaki', + 'kinky', + 'kiosk', + 'kitty', + 'knack', + 'knave', + 'knead', + 'kneed', + 'kneel', + 'knelt', + 'knife', + 'knock', + 'knoll', + 'known', + 'koala', + 'krill', + 'label', + 'labor', + 'laden', + 'ladle', + 'lager', + 'lance', + 'lanky', + 'lapel', + 'lapse', + 'large', + 'larva', + 'lasso', + 'latch', + 'later', + 'lathe', + 'latte', + 'laugh', + 'layer', + 'leach', + 'leafy', + 'leaky', + 'leant', + 'leapt', + 'learn', + 'lease', + 'leash', + 'least', + 'leave', + 'ledge', + 'leech', + 'leery', + 'lefty', + 'legal', + 'leggy', + 'lemon', + 'lemur', + 'leper', + 'level', + 'lever', + 'libel', + 'liege', + 'light', + 'liken', + 'lilac', + 'limbo', + 'limit', + 'linen', + 'liner', + 'lingo', + 'lipid', + 'lithe', + 'liver', + 'livid', + 'llama', + 'loamy', + 'loath', + 'lobby', + 'local', + 'locus', + 'lodge', + 'lofty', + 'logic', + 'login', + 'loopy', + 'loose', + 'lorry', + 'loser', + 'louse', + 'lousy', + 'lover', + 'lower', + 'lowly', + 'loyal', + 'lucid', + 'lucky', + 'lumen', + 'lumpy', + 'lunar', + 'lunch', + 'lunge', + 'lupus', + 'lurch', + 'lurid', + 'lusty', + 'lying', + 'lymph', + 'lynch', + 'lyric', + 'macaw', + 'macho', + 'macro', + 'madam', + 'madly', + 'mafia', + 'magic', + 'magma', + 'maize', + 'major', + 'maker', + 'mambo', + 'mamma', + 'mammy', + 'manga', + 'mange', + 'mango', + 'mangy', + 'mania', + 'manic', + 'manly', + 'manor', + 'maple', + 'march', + 'marry', + 'marsh', + 'mason', + 'masse', + 'match', + 'matey', + 'mauve', + 'maxim', + 'maybe', + 'mayor', + 'mealy', + 'meant', + 'meaty', + 'mecca', + 'medal', + 'media', + 'medic', + 'melee', + 'melon', + 'mercy', + 'merge', + 'merit', + 'merry', + 'metal', + 'meter', + 'metro', + 'micro', + 'midge', + 'midst', + 'might', + 'milky', + 'mimic', + 'mince', + 'miner', + 'minim', + 'minor', + 'minty', + 'minus', + 'mirth', + 'miser', + 'missy', + 'mocha', + 'modal', + 'model', + 'modem', + 'mogul', + 'moist', + 'molar', + 'moldy', + 'money', + 'month', + 'moody', + 'moose', + 'moral', + 'moron', + 'morph', + 'mossy', + 'motel', + 'motif', + 'motor', + 'motto', + 'moult', + 'mound', + 'mount', + 'mourn', + 'mouse', + 'mouth', + 'mover', + 'movie', + 'mower', + 'mucky', + 'mucus', + 'muddy', + 'mulch', + 'mummy', + 'munch', + 'mural', + 'murky', + 'mushy', + 'music', + 'musky', + 'musty', + 'myrrh', + 'nadir', + 'naive', + 'nanny', + 'nasal', + 'nasty', + 'natal', + 'naval', + 'navel', + 'needy', + 'neigh', + 'nerdy', + 'nerve', + 'never', + 'newer', + 'newly', + 'nicer', + 'niche', + 'niece', + 'night', + 'ninja', + 'ninny', + 'ninth', + 'noble', + 'nobly', + 'noise', + 'noisy', + 'nomad', + 'noose', + 'north', + 'nosey', + 'notch', + 'novel', + 'nudge', + 'nurse', + 'nutty', + 'nylon', + 'nymph', + 'oaken', + 'obese', + 'occur', + 'ocean', + 'octal', + 'octet', + 'odder', + 'oddly', + 'offal', + 'offer', + 'often', + 'olden', + 'older', + 'olive', + 'ombre', + 'omega', + 'onion', + 'onset', + 'opera', + 'opine', + 'opium', + 'optic', + 'orbit', + 'order', + 'organ', + 'other', + 'otter', + 'ought', + 'ounce', + 'outdo', + 'outer', + 'outgo', + 'ovary', + 'ovate', + 'overt', + 'ovine', + 'ovoid', + 'owing', + 'owner', + 'oxide', + 'ozone', + 'paddy', + 'pagan', + 'paint', + 'paler', + 'palsy', + 'panel', + 'panic', + 'pansy', + 'papal', + 'paper', + 'parer', + 'parka', + 'parry', + 'parse', + 'party', + 'pasta', + 'paste', + 'pasty', + 'patch', + 'patio', + 'patsy', + 'patty', + 'pause', + 'payee', + 'payer', + 'peace', + 'peach', + 'pearl', + 'pecan', + 'pedal', + 'penal', + 'pence', + 'penne', + 'penny', + 'perch', + 'peril', + 'perky', + 'pesky', + 'pesto', + 'petal', + 'petty', + 'phase', + 'phone', + 'phony', + 'photo', + 'piano', + 'picky', + 'piece', + 'piety', + 'piggy', + 'pilot', + 'pinch', + 'piney', + 'pinky', + 'pinto', + 'piper', + 'pique', + 'pitch', + 'pithy', + 'pivot', + 'pixel', + 'pixie', + 'pizza', + 'place', + 'plaid', + 'plain', + 'plait', + 'plane', + 'plank', + 'plant', + 'plate', + 'plaza', + 'plead', + 'pleat', + 'plied', + 'plier', + 'pluck', + 'plumb', + 'plume', + 'plump', + 'plunk', + 'plush', + 'poesy', + 'point', + 'poise', + 'poker', + 'polar', + 'polka', + 'polyp', + 'pooch', + 'poppy', + 'porch', + 'poser', + 'posit', + 'posse', + 'pouch', + 'pound', + 'pouty', + 'power', + 'prank', + 'prawn', + 'preen', + 'press', + 'price', + 'prick', + 'pride', + 'pried', + 'prime', + 'primo', + 'print', + 'prior', + 'prism', + 'privy', + 'prize', + 'probe', + 'prone', + 'prong', + 'proof', + 'prose', + 'proud', + 'prove', + 'prowl', + 'proxy', + 'prude', + 'prune', + 'psalm', + 'pubic', + 'pudgy', + 'puffy', + 'pulpy', + 'pulse', + 'punch', + 'pupal', + 'pupil', + 'puppy', + 'puree', + 'purer', + 'purge', + 'purse', + 'pushy', + 'putty', + 'pygmy', + 'quack', + 'quail', + 'quake', + 'qualm', + 'quark', + 'quart', + 'quash', + 'quasi', + 'queen', + 'queer', + 'quell', + 'query', + 'quest', + 'queue', + 'quick', + 'quiet', + 'quill', + 'quilt', + 'quirk', + 'quite', + 'quota', + 'quote', + 'quoth', + 'rabbi', + 'rabid', + 'racer', + 'radar', + 'radii', + 'radio', + 'rainy', + 'raise', + 'rajah', + 'rally', + 'ralph', + 'ramen', + 'ranch', + 'randy', + 'range', + 'rapid', + 'rarer', + 'raspy', + 'ratio', + 'ratty', + 'raven', + 'rayon', + 'razor', + 'reach', + 'react', + 'ready', + 'realm', + 'rearm', + 'rebar', + 'rebel', + 'rebus', + 'rebut', + 'recap', + 'recur', + 'recut', + 'reedy', + 'refer', + 'refit', + 'regal', + 'rehab', + 'reign', + 'relax', + 'relay', + 'relic', + 'remit', + 'renal', + 'renew', + 'repay', + 'repel', + 'reply', + 'rerun', + 'reset', + 'resin', + 'retch', + 'retro', + 'retry', + 'reuse', + 'revel', + 'revue', + 'rhino', + 'rhyme', + 'rider', + 'ridge', + 'rifle', + 'right', + 'rigid', + 'rigor', + 'rinse', + 'ripen', + 'riper', + 'risen', + 'riser', + 'risky', + 'rival', + 'river', + 'rivet', + 'roach', + 'roast', + 'robin', + 'robot', + 'rocky', + 'rodeo', + 'roger', + 'rogue', + 'roomy', + 'roost', + 'rotor', + 'rouge', + 'rough', + 'round', + 'rouse', + 'route', + 'rover', + 'rowdy', + 'rower', + 'royal', + 'ruddy', + 'ruder', + 'rugby', + 'ruler', + 'rumba', + 'rumor', + 'rupee', + 'rural', + 'rusty', + 'sadly', + 'safer', + 'saint', + 'salad', + 'sally', + 'salon', + 'salsa', + 'salty', + 'salve', + 'salvo', + 'sandy', + 'saner', + 'sappy', + 'sassy', + 'satin', + 'satyr', + 'sauce', + 'saucy', + 'sauna', + 'saute', + 'savor', + 'savoy', + 'savvy', + 'scald', + 'scale', + 'scalp', + 'scaly', + 'scamp', + 'scant', + 'scare', + 'scarf', + 'scary', + 'scene', + 'scent', + 'scion', + 'scoff', + 'scold', + 'scone', + 'scoop', + 'scope', + 'score', + 'scorn', + 'scour', + 'scout', + 'scowl', + 'scram', + 'scrap', + 'scree', + 'screw', + 'scrub', + 'scrum', + 'scuba', + 'sedan', + 'seedy', + 'segue', + 'seize', + 'semen', + 'sense', + 'sepia', + 'serif', + 'serum', + 'serve', + 'setup', + 'seven', + 'sever', + 'sewer', + 'shack', + 'shade', + 'shady', + 'shaft', + 'shake', + 'shaky', + 'shale', + 'shall', + 'shalt', + 'shame', + 'shank', + 'shape', + 'shard', + 'share', + 'shark', + 'sharp', + 'shave', + 'shawl', + 'shear', + 'sheen', + 'sheep', + 'sheer', + 'sheet', + 'sheik', + 'shelf', + 'shell', + 'shied', + 'shift', + 'shine', + 'shiny', + 'shire', + 'shirk', + 'shirt', + 'shoal', + 'shock', + 'shone', + 'shook', + 'shoot', + 'shore', + 'shorn', + 'short', + 'shout', + 'shove', + 'shown', + 'showy', + 'shrew', + 'shrub', + 'shrug', + 'shuck', + 'shunt', + 'shush', + 'shyly', + 'siege', + 'sieve', + 'sight', + 'sigma', + 'silky', + 'silly', + 'since', + 'sinew', + 'singe', + 'siren', + 'sissy', + 'sixth', + 'sixty', + 'skate', + 'skier', + 'skiff', + 'skill', + 'skimp', + 'skirt', + 'skulk', + 'skull', + 'skunk', + 'slack', + 'slain', + 'slang', + 'slant', + 'slash', + 'slate', + 'slave', + 'sleek', + 'sleep', + 'sleet', + 'slept', + 'slice', + 'slick', + 'slide', + 'slime', + 'slimy', + 'sling', + 'slink', + 'sloop', + 'slope', + 'slosh', + 'sloth', + 'slump', + 'slung', + 'slunk', + 'slurp', + 'slush', + 'slyly', + 'smack', + 'small', + 'smart', + 'smash', + 'smear', + 'smell', + 'smelt', + 'smile', + 'smirk', + 'smite', + 'smith', + 'smock', + 'smoke', + 'smoky', + 'smote', + 'snack', + 'snail', + 'snake', + 'snaky', + 'snare', + 'snarl', + 'sneak', + 'sneer', + 'snide', + 'sniff', + 'snipe', + 'snoop', + 'snore', + 'snort', + 'snout', + 'snowy', + 'snuck', + 'snuff', + 'soapy', + 'sober', + 'soggy', + 'solar', + 'solid', + 'solve', + 'sonar', + 'sonic', + 'sooth', + 'sooty', + 'sorry', + 'sound', + 'south', + 'sower', + 'space', + 'spade', + 'spank', + 'spare', + 'spark', + 'spasm', + 'spawn', + 'speak', + 'spear', + 'speck', + 'speed', + 'spell', + 'spelt', + 'spend', + 'spent', + 'sperm', + 'spice', + 'spicy', + 'spied', + 'spiel', + 'spike', + 'spiky', + 'spill', + 'spilt', + 'spine', + 'spiny', + 'spire', + 'spite', + 'splat', + 'split', + 'spoil', + 'spoke', + 'spoof', + 'spook', + 'spool', + 'spoon', + 'spore', + 'sport', + 'spout', + 'spray', + 'spree', + 'sprig', + 'spunk', + 'spurn', + 'spurt', + 'squad', + 'squat', + 'squib', + 'stack', + 'staff', + 'stage', + 'staid', + 'stain', + 'stair', + 'stake', + 'stale', + 'stalk', + 'stall', + 'stamp', + 'stand', + 'stank', + 'stare', + 'stark', + 'start', + 'stash', + 'state', + 'stave', + 'stead', + 'steak', + 'steal', + 'steam', + 'steed', + 'steel', + 'steep', + 'steer', + 'stein', + 'stern', + 'stick', + 'stiff', + 'still', + 'stilt', + 'sting', + 'stink', + 'stint', + 'stock', + 'stoic', + 'stoke', + 'stole', + 'stomp', + 'stone', + 'stony', + 'stood', + 'stool', + 'stoop', + 'store', + 'stork', + 'storm', + 'story', + 'stout', + 'stove', + 'strap', + 'straw', + 'stray', + 'strip', + 'strut', + 'stuck', + 'study', + 'stuff', + 'stump', + 'stung', + 'stunk', + 'stunt', + 'style', + 'suave', + 'sugar', + 'suing', + 'suite', + 'sulky', + 'sully', + 'sumac', + 'sunny', + 'super', + 'surer', + 'surge', + 'surly', + 'sushi', + 'swami', + 'swamp', + 'swarm', + 'swash', + 'swath', + 'swear', + 'sweat', + 'sweep', + 'sweet', + 'swell', + 'swept', + 'swift', + 'swill', + 'swine', + 'swing', + 'swirl', + 'swish', + 'swoon', + 'swoop', + 'sword', + 'swore', + 'sworn', + 'swung', + 'synod', + 'syrup', + 'tabby', + 'table', + 'taboo', + 'tacit', + 'tacky', + 'taffy', + 'taint', + 'taken', + 'taker', + 'tally', + 'talon', + 'tamer', + 'tango', + 'tangy', + 'taper', + 'tapir', + 'tardy', + 'tarot', + 'taste', + 'tasty', + 'tatty', + 'taunt', + 'tawny', + 'teach', + 'teary', + 'tease', + 'teddy', + 'teeth', + 'tempo', + 'tenet', + 'tenor', + 'tense', + 'tenth', + 'tepee', + 'tepid', + 'terra', + 'terse', + 'testy', + 'thank', + 'theft', + 'their', + 'theme', + 'there', + 'these', + 'theta', + 'thick', + 'thief', + 'thigh', + 'thing', + 'think', + 'third', + 'thong', + 'thorn', + 'those', + 'three', + 'threw', + 'throb', + 'throw', + 'thrum', + 'thumb', + 'thump', + 'thyme', + 'tiara', + 'tibia', + 'tidal', + 'tiger', + 'tight', + 'tilde', + 'timer', + 'timid', + 'tipsy', + 'titan', + 'tithe', + 'title', + 'toast', + 'today', + 'toddy', + 'token', + 'tonal', + 'tonga', + 'tonic', + 'tooth', + 'topaz', + 'topic', + 'torch', + 'torso', + 'torus', + 'total', + 'totem', + 'touch', + 'tough', + 'towel', + 'tower', + 'toxic', + 'toxin', + 'trace', + 'track', + 'tract', + 'trade', + 'trail', + 'train', + 'trait', + 'tramp', + 'trash', + 'trawl', + 'tread', + 'treat', + 'trend', + 'triad', + 'trial', + 'tribe', + 'trice', + 'trick', + 'tried', + 'tripe', + 'trite', + 'troll', + 'troop', + 'trope', + 'trout', + 'trove', + 'truce', + 'truck', + 'truer', + 'truly', + 'trump', + 'trunk', + 'truss', + 'trust', + 'truth', + 'tryst', + 'tubal', + 'tuber', + 'tulip', + 'tulle', + 'tumor', + 'tunic', + 'turbo', + 'tutor', + 'twang', + 'tweak', + 'tweed', + 'tweet', + 'twice', + 'twine', + 'twirl', + 'twist', + 'twixt', + 'tying', + 'udder', + 'ulcer', + 'ultra', + 'umbra', + 'uncle', + 'uncut', + 'under', + 'undid', + 'undue', + 'unfed', + 'unfit', + 'unify', + 'union', + 'unite', + 'unity', + 'unlit', + 'unmet', + 'unset', + 'untie', + 'until', + 'unwed', + 'unzip', + 'upper', + 'upset', + 'urban', + 'urine', + 'usage', + 'usher', + 'using', + 'usual', + 'usurp', + 'utile', + 'utter', + 'vague', + 'valet', + 'valid', + 'valor', + 'value', + 'valve', + 'vapid', + 'vapor', + 'vault', + 'vaunt', + 'vegan', + 'venom', + 'venue', + 'verge', + 'verse', + 'verso', + 'verve', + 'vicar', + 'video', + 'vigil', + 'vigor', + 'villa', + 'vinyl', + 'viola', + 'viper', + 'viral', + 'virus', + 'visit', + 'visor', + 'vista', + 'vital', + 'vivid', + 'vixen', + 'vocal', + 'vodka', + 'vogue', + 'voice', + 'voila', + 'vomit', + 'voter', + 'vouch', + 'vowel', + 'vying', + 'wacky', + 'wafer', + 'wager', + 'wagon', + 'waist', + 'waive', + 'waltz', + 'warty', + 'waste', + 'watch', + 'water', + 'waver', + 'waxen', + 'weary', + 'weave', + 'wedge', + 'weedy', + 'weigh', + 'weird', + 'welch', + 'welsh', + 'wench', + 'whack', + 'whale', + 'wharf', + 'wheat', + 'wheel', + 'whelp', + 'where', + 'which', + 'whiff', + 'while', + 'whine', + 'whiny', + 'whirl', + 'whisk', + 'white', + 'whole', + 'whoop', + 'whose', + 'widen', + 'wider', + 'widow', + 'width', + 'wield', + 'wight', + 'willy', + 'wimpy', + 'wince', + 'winch', + 'windy', + 'wiser', + 'wispy', + 'witch', + 'witty', + 'woken', + 'woman', + 'women', + 'woody', + 'wooer', + 'wooly', + 'woozy', + 'wordy', + 'world', + 'worry', + 'worse', + 'worst', + 'worth', + 'would', + 'wound', + 'woven', + 'wrack', + 'wrath', + 'wreak', + 'wreck', + 'wrest', + 'wring', + 'wrist', + 'write', + 'wrong', + 'wrote', + 'wrung', + 'wryly', + 'yacht', + 'yearn', + 'yeast', + 'yield', + 'young', + 'youth', + 'zebra', + 'zesty', + 'zonal', +]; + +/** The list of valid guesses, of which the list of possible words is a subset */ +export const allowed = new Set([ + ...words, + 'aahed', + 'aalii', + 'aargh', + 'aarti', + 'abaca', + 'abaci', + 'abacs', + 'abaft', + 'abaka', + 'abamp', + 'aband', + 'abash', + 'abask', + 'abaya', + 'abbas', + 'abbed', + 'abbes', + 'abcee', + 'abeam', + 'abear', + 'abele', + 'abers', + 'abets', + 'abies', + 'abler', + 'ables', + 'ablet', + 'ablow', + 'abmho', + 'abohm', + 'aboil', + 'aboma', + 'aboon', + 'abord', + 'abore', + 'abram', + 'abray', + 'abrim', + 'abrin', + 'abris', + 'absey', + 'absit', + 'abuna', + 'abune', + 'abuts', + 'abuzz', + 'abyes', + 'abysm', + 'acais', + 'acari', + 'accas', + 'accoy', + 'acerb', + 'acers', + 'aceta', + 'achar', + 'ached', + 'aches', + 'achoo', + 'acids', + 'acidy', + 'acing', + 'acini', + 'ackee', + 'acker', + 'acmes', + 'acmic', + 'acned', + 'acnes', + 'acock', + 'acold', + 'acred', + 'acres', + 'acros', + 'acted', + 'actin', + 'acton', + 'acyls', + 'adaws', + 'adays', + 'adbot', + 'addax', + 'added', + 'adder', + 'addio', + 'addle', + 'adeem', + 'adhan', + 'adieu', + 'adios', + 'adits', + 'adman', + 'admen', + 'admix', + 'adobo', + 'adown', + 'adoze', + 'adrad', + 'adred', + 'adsum', + 'aduki', + 'adunc', + 'adust', + 'advew', + 'adyta', + 'adzed', + 'adzes', + 'aecia', + 'aedes', + 'aegis', + 'aeons', + 'aerie', + 'aeros', + 'aesir', + 'afald', + 'afara', + 'afars', + 'afear', + 'aflaj', + 'afore', + 'afrit', + 'afros', + 'agama', + 'agami', + 'agars', + 'agast', + 'agave', + 'agaze', + 'agene', + 'agers', + 'agger', + 'aggie', + 'aggri', + 'aggro', + 'aggry', + 'aghas', + 'agila', + 'agios', + 'agism', + 'agist', + 'agita', + 'aglee', + 'aglet', + 'agley', + 'agloo', + 'aglus', + 'agmas', + 'agoge', + 'agone', + 'agons', + 'agood', + 'agria', + 'agrin', + 'agros', + 'agued', + 'agues', + 'aguna', + 'aguti', + 'aheap', + 'ahent', + 'ahigh', + 'ahind', + 'ahing', + 'ahint', + 'ahold', + 'ahull', + 'ahuru', + 'aidas', + 'aided', + 'aides', + 'aidoi', + 'aidos', + 'aiery', + 'aigas', + 'aight', + 'ailed', + 'aimed', + 'aimer', + 'ainee', + 'ainga', + 'aioli', + 'aired', + 'airer', + 'airns', + 'airth', + 'airts', + 'aitch', + 'aitus', + 'aiver', + 'aiyee', + 'aizle', + 'ajies', + 'ajiva', + 'ajuga', + 'ajwan', + 'akees', + 'akela', + 'akene', + 'aking', + 'akita', + 'akkas', + 'alaap', + 'alack', + 'alamo', + 'aland', + 'alane', + 'alang', + 'alans', + 'alant', + 'alapa', + 'alaps', + 'alary', + 'alate', + 'alays', + 'albas', + 'albee', + 'alcid', + 'alcos', + 'aldea', + 'alder', + 'aldol', + 'aleck', + 'alecs', + 'alefs', + 'aleft', + 'aleph', + 'alews', + 'aleye', + 'alfas', + 'algal', + 'algas', + 'algid', + 'algin', + 'algor', + 'algum', + 'alias', + 'alifs', + 'aline', + 'alist', + 'aliya', + 'alkie', + 'alkos', + 'alkyd', + 'alkyl', + 'allee', + 'allel', + 'allis', + 'allod', + 'allyl', + 'almah', + 'almas', + 'almeh', + 'almes', + 'almud', + 'almug', + 'alods', + 'aloed', + 'aloes', + 'aloha', + 'aloin', + 'aloos', + 'alowe', + 'altho', + 'altos', + 'alula', + 'alums', + 'alure', + 'alvar', + 'alway', + 'amahs', + 'amain', + 'amate', + 'amaut', + 'amban', + 'ambit', + 'ambos', + 'ambry', + 'ameba', + 'ameer', + 'amene', + 'amens', + 'ament', + 'amias', + 'amice', + 'amici', + 'amide', + 'amido', + 'amids', + 'amies', + 'amiga', + 'amigo', + 'amine', + 'amino', + 'amins', + 'amirs', + 'amlas', + 'amman', + 'ammon', + 'ammos', + 'amnia', + 'amnic', + 'amnio', + 'amoks', + 'amole', + 'amort', + 'amour', + 'amove', + 'amowt', + 'amped', + 'ampul', + 'amrit', + 'amuck', + 'amyls', + 'anana', + 'anata', + 'ancho', + 'ancle', + 'ancon', + 'andro', + 'anear', + 'anele', + 'anent', + 'angas', + 'anglo', + 'anigh', + 'anile', + 'anils', + 'anima', + 'animi', + 'anion', + 'anise', + 'anker', + 'ankhs', + 'ankus', + 'anlas', + 'annal', + 'annas', + 'annat', + 'anoas', + 'anole', + 'anomy', + 'ansae', + 'antae', + 'antar', + 'antas', + 'anted', + 'antes', + 'antis', + 'antra', + 'antre', + 'antsy', + 'anura', + 'anyon', + 'apace', + 'apage', + 'apaid', + 'apayd', + 'apays', + 'apeak', + 'apeek', + 'apers', + 'apert', + 'apery', + 'apgar', + 'aphis', + 'apian', + 'apiol', + 'apish', + 'apism', + 'apode', + 'apods', + 'apoop', + 'aport', + 'appal', + 'appay', + 'appel', + 'appro', + 'appui', + 'appuy', + 'apres', + 'apses', + 'apsis', + 'apsos', + 'apted', + 'apter', + 'aquae', + 'aquas', + 'araba', + 'araks', + 'arame', + 'arars', + 'arbas', + 'arced', + 'archi', + 'arcos', + 'arcus', + 'ardeb', + 'ardri', + 'aread', + 'areae', + 'areal', + 'arear', + 'areas', + 'areca', + 'aredd', + 'arede', + 'arefy', + 'areic', + 'arene', + 'arepa', + 'arere', + 'arete', + 'arets', + 'arett', + 'argal', + 'argan', + 'argil', + 'argle', + 'argol', + 'argon', + 'argot', + 'argus', + 'arhat', + 'arias', + 'ariel', + 'ariki', + 'arils', + 'ariot', + 'arish', + 'arked', + 'arled', + 'arles', + 'armed', + 'armer', + 'armet', + 'armil', + 'arnas', + 'arnut', + 'aroba', + 'aroha', + 'aroid', + 'arpas', + 'arpen', + 'arrah', + 'arras', + 'arret', + 'arris', + 'arroz', + 'arsed', + 'arses', + 'arsey', + 'arsis', + 'artal', + 'artel', + 'artic', + 'artis', + 'aruhe', + 'arums', + 'arval', + 'arvee', + 'arvos', + 'aryls', + 'asana', + 'ascon', + 'ascus', + 'asdic', + 'ashed', + 'ashes', + 'ashet', + 'asked', + 'asker', + 'askoi', + 'askos', + 'aspen', + 'asper', + 'aspic', + 'aspie', + 'aspis', + 'aspro', + 'assai', + 'assam', + 'asses', + 'assez', + 'assot', + 'aster', + 'astir', + 'astun', + 'asura', + 'asway', + 'aswim', + 'asyla', + 'ataps', + 'ataxy', + 'atigi', + 'atilt', + 'atimy', + 'atlas', + 'atman', + 'atmas', + 'atmos', + 'atocs', + 'atoke', + 'atoks', + 'atoms', + 'atomy', + 'atony', + 'atopy', + 'atria', + 'atrip', + 'attap', + 'attar', + 'atuas', + 'audad', + 'auger', + 'aught', + 'aulas', + 'aulic', + 'auloi', + 'aulos', + 'aumil', + 'aunes', + 'aunts', + 'aurae', + 'aural', + 'aurar', + 'auras', + 'aurei', + 'aures', + 'auric', + 'auris', + 'aurum', + 'autos', + 'auxin', + 'avale', + 'avant', + 'avast', + 'avels', + 'avens', + 'avers', + 'avgas', + 'avine', + 'avion', + 'avise', + 'aviso', + 'avize', + 'avows', + 'avyze', + 'awarn', + 'awato', + 'awave', + 'aways', + 'awdls', + 'aweel', + 'aweto', + 'awing', + 'awmry', + 'awned', + 'awner', + 'awols', + 'awork', + 'axels', + 'axile', + 'axils', + 'axing', + 'axite', + 'axled', + 'axles', + 'axman', + 'axmen', + 'axoid', + 'axone', + 'axons', + 'ayahs', + 'ayaya', + 'ayelp', + 'aygre', + 'ayins', + 'ayont', + 'ayres', + 'ayrie', + 'azans', + 'azide', + 'azido', + 'azine', + 'azlon', + 'azoic', + 'azole', + 'azons', + 'azote', + 'azoth', + 'azuki', + 'azurn', + 'azury', + 'azygy', + 'azyme', + 'azyms', + 'baaed', + 'baals', + 'babas', + 'babel', + 'babes', + 'babka', + 'baboo', + 'babul', + 'babus', + 'bacca', + 'bacco', + 'baccy', + 'bacha', + 'bachs', + 'backs', + 'baddy', + 'baels', + 'baffs', + 'baffy', + 'bafts', + 'baghs', + 'bagie', + 'bahts', + 'bahus', + 'bahut', + 'bails', + 'bairn', + 'baisa', + 'baith', + 'baits', + 'baiza', + 'baize', + 'bajan', + 'bajra', + 'bajri', + 'bajus', + 'baked', + 'baken', + 'bakes', + 'bakra', + 'balas', + 'balds', + 'baldy', + 'baled', + 'bales', + 'balks', + 'balky', + 'balls', + 'bally', + 'balms', + 'baloo', + 'balsa', + 'balti', + 'balun', + 'balus', + 'bambi', + 'banak', + 'banco', + 'bancs', + 'banda', + 'bandh', + 'bands', + 'bandy', + 'baned', + 'banes', + 'bangs', + 'bania', + 'banks', + 'banns', + 'bants', + 'bantu', + 'banty', + 'banya', + 'bapus', + 'barbe', + 'barbs', + 'barby', + 'barca', + 'barde', + 'bardo', + 'bards', + 'bardy', + 'bared', + 'barer', + 'bares', + 'barfi', + 'barfs', + 'baric', + 'barks', + 'barky', + 'barms', + 'barmy', + 'barns', + 'barny', + 'barps', + 'barra', + 'barre', + 'barro', + 'barry', + 'barye', + 'basan', + 'based', + 'basen', + 'baser', + 'bases', + 'basho', + 'basij', + 'basks', + 'bason', + 'basse', + 'bassi', + 'basso', + 'bassy', + 'basta', + 'basti', + 'basto', + 'basts', + 'bated', + 'bates', + 'baths', + 'batik', + 'batta', + 'batts', + 'battu', + 'bauds', + 'bauks', + 'baulk', + 'baurs', + 'bavin', + 'bawds', + 'bawks', + 'bawls', + 'bawns', + 'bawrs', + 'bawty', + 'bayed', + 'bayer', + 'bayes', + 'bayle', + 'bayts', + 'bazar', + 'bazoo', + 'beads', + 'beaks', + 'beaky', + 'beals', + 'beams', + 'beamy', + 'beano', + 'beans', + 'beany', + 'beare', + 'bears', + 'beath', + 'beats', + 'beaty', + 'beaus', + 'beaut', + 'beaux', + 'bebop', + 'becap', + 'becke', + 'becks', + 'bedad', + 'bedel', + 'bedes', + 'bedew', + 'bedim', + 'bedye', + 'beedi', + 'beefs', + 'beeps', + 'beers', + 'beery', + 'beets', + 'befog', + 'begad', + 'begar', + 'begem', + 'begot', + 'begum', + 'beige', + 'beigy', + 'beins', + 'bekah', + 'belah', + 'belar', + 'belay', + 'belee', + 'belga', + 'bells', + 'belon', + 'belts', + 'bemad', + 'bemas', + 'bemix', + 'bemud', + 'bends', + 'bendy', + 'benes', + 'benet', + 'benga', + 'benis', + 'benne', + 'benni', + 'benny', + 'bento', + 'bents', + 'benty', + 'bepat', + 'beray', + 'beres', + 'bergs', + 'berko', + 'berks', + 'berme', + 'berms', + 'berob', + 'beryl', + 'besat', + 'besaw', + 'besee', + 'beses', + 'besit', + 'besom', + 'besot', + 'besti', + 'bests', + 'betas', + 'beted', + 'betes', + 'beths', + 'betid', + 'beton', + 'betta', + 'betty', + 'bever', + 'bevor', + 'bevue', + 'bevvy', + 'bewet', + 'bewig', + 'bezes', + 'bezil', + 'bezzy', + 'bhais', + 'bhaji', + 'bhang', + 'bhats', + 'bhels', + 'bhoot', + 'bhuna', + 'bhuts', + 'biach', + 'biali', + 'bialy', + 'bibbs', + 'bibes', + 'biccy', + 'bices', + 'bided', + 'bider', + 'bides', + 'bidet', + 'bidis', + 'bidon', + 'bield', + 'biers', + 'biffo', + 'biffs', + 'biffy', + 'bifid', + 'bigae', + 'biggs', + 'biggy', + 'bigha', + 'bight', + 'bigly', + 'bigos', + 'bijou', + 'biked', + 'biker', + 'bikes', + 'bikie', + 'bilbo', + 'bilby', + 'biled', + 'biles', + 'bilgy', + 'bilks', + 'bills', + 'bimah', + 'bimas', + 'bimbo', + 'binal', + 'bindi', + 'binds', + 'biner', + 'bines', + 'bings', + 'bingy', + 'binit', + 'binks', + 'bints', + 'biogs', + 'biont', + 'biota', + 'biped', + 'bipod', + 'birds', + 'birks', + 'birle', + 'birls', + 'biros', + 'birrs', + 'birse', + 'birsy', + 'bises', + 'bisks', + 'bisom', + 'bitch', + 'biter', + 'bites', + 'bitos', + 'bitou', + 'bitsy', + 'bitte', + 'bitts', + 'bivia', + 'bivvy', + 'bizes', + 'bizzo', + 'bizzy', + 'blabs', + 'blads', + 'blady', + 'blaer', + 'blaes', + 'blaff', + 'blags', + 'blahs', + 'blain', + 'blams', + 'blart', + 'blase', + 'blash', + 'blate', + 'blats', + 'blatt', + 'blaud', + 'blawn', + 'blaws', + 'blays', + 'blear', + 'blebs', + 'blech', + 'blees', + 'blent', + 'blert', + 'blest', + 'blets', + 'bleys', + 'blimy', + 'bling', + 'blini', + 'blins', + 'bliny', + 'blips', + 'blist', + 'blite', + 'blits', + 'blive', + 'blobs', + 'blocs', + 'blogs', + 'blook', + 'bloop', + 'blore', + 'blots', + 'blows', + 'blowy', + 'blubs', + 'blude', + 'bluds', + 'bludy', + 'blued', + 'blues', + 'bluet', + 'bluey', + 'bluid', + 'blume', + 'blunk', + 'blurs', + 'blype', + 'boabs', + 'boaks', + 'boars', + 'boart', + 'boats', + 'bobac', + 'bobak', + 'bobas', + 'bobol', + 'bobos', + 'bocca', + 'bocce', + 'bocci', + 'boche', + 'bocks', + 'boded', + 'bodes', + 'bodge', + 'bodhi', + 'bodle', + 'boeps', + 'boets', + 'boeuf', + 'boffo', + 'boffs', + 'bogan', + 'bogey', + 'boggy', + 'bogie', + 'bogle', + 'bogue', + 'bogus', + 'bohea', + 'bohos', + 'boils', + 'boing', + 'boink', + 'boite', + 'boked', + 'bokeh', + 'bokes', + 'bokos', + 'bolar', + 'bolas', + 'bolds', + 'boles', + 'bolix', + 'bolls', + 'bolos', + 'bolts', + 'bolus', + 'bomas', + 'bombe', + 'bombo', + 'bombs', + 'bonce', + 'bonds', + 'boned', + 'boner', + 'bones', + 'bongs', + 'bonie', + 'bonks', + 'bonne', + 'bonny', + 'bonza', + 'bonze', + 'booai', + 'booay', + 'boobs', + 'boody', + 'booed', + 'boofy', + 'boogy', + 'boohs', + 'books', + 'booky', + 'bools', + 'booms', + 'boomy', + 'boong', + 'boons', + 'boord', + 'boors', + 'boose', + 'boots', + 'boppy', + 'borak', + 'boral', + 'boras', + 'borde', + 'bords', + 'bored', + 'boree', + 'borel', + 'borer', + 'bores', + 'borgo', + 'boric', + 'borks', + 'borms', + 'borna', + 'boron', + 'borts', + 'borty', + 'bortz', + 'bosie', + 'bosks', + 'bosky', + 'boson', + 'bosun', + 'botas', + 'botel', + 'botes', + 'bothy', + 'botte', + 'botts', + 'botty', + 'bouge', + 'bouks', + 'boult', + 'bouns', + 'bourd', + 'bourg', + 'bourn', + 'bouse', + 'bousy', + 'bouts', + 'bovid', + 'bowat', + 'bowed', + 'bower', + 'bowes', + 'bowet', + 'bowie', + 'bowls', + 'bowne', + 'bowrs', + 'bowse', + 'boxed', + 'boxen', + 'boxes', + 'boxla', + 'boxty', + 'boyar', + 'boyau', + 'boyed', + 'boyfs', + 'boygs', + 'boyla', + 'boyos', + 'boysy', + 'bozos', + 'braai', + 'brach', + 'brack', + 'bract', + 'brads', + 'braes', + 'brags', + 'brail', + 'braks', + 'braky', + 'brame', + 'brane', + 'brank', + 'brans', + 'brant', + 'brast', + 'brats', + 'brava', + 'bravi', + 'braws', + 'braxy', + 'brays', + 'braza', + 'braze', + 'bream', + 'brede', + 'breds', + 'breem', + 'breer', + 'brees', + 'breid', + 'breis', + 'breme', + 'brens', + 'brent', + 'brere', + 'brers', + 'breve', + 'brews', + 'breys', + 'brier', + 'bries', + 'brigs', + 'briki', + 'briks', + 'brill', + 'brims', + 'brins', + 'brios', + 'brise', + 'briss', + 'brith', + 'brits', + 'britt', + 'brize', + 'broch', + 'brock', + 'brods', + 'brogh', + 'brogs', + 'brome', + 'bromo', + 'bronc', + 'brond', + 'brool', + 'broos', + 'brose', + 'brosy', + 'brows', + 'brugh', + 'bruin', + 'bruit', + 'brule', + 'brume', + 'brung', + 'brusk', + 'brust', + 'bruts', + 'buats', + 'buaze', + 'bubal', + 'bubas', + 'bubba', + 'bubbe', + 'bubby', + 'bubus', + 'buchu', + 'bucko', + 'bucks', + 'bucku', + 'budas', + 'budis', + 'budos', + 'buffa', + 'buffe', + 'buffi', + 'buffo', + 'buffs', + 'buffy', + 'bufos', + 'bufty', + 'buhls', + 'buhrs', + 'buiks', + 'buist', + 'bukes', + 'bulbs', + 'bulgy', + 'bulks', + 'bulla', + 'bulls', + 'bulse', + 'bumbo', + 'bumfs', + 'bumph', + 'bumps', + 'bumpy', + 'bunas', + 'bunce', + 'bunco', + 'bunde', + 'bundh', + 'bunds', + 'bundt', + 'bundu', + 'bundy', + 'bungs', + 'bungy', + 'bunia', + 'bunje', + 'bunjy', + 'bunko', + 'bunks', + 'bunns', + 'bunts', + 'bunty', + 'bunya', + 'buoys', + 'buppy', + 'buran', + 'buras', + 'burbs', + 'burds', + 'buret', + 'burfi', + 'burgh', + 'burgs', + 'burin', + 'burka', + 'burke', + 'burks', + 'burls', + 'burns', + 'buroo', + 'burps', + 'burqa', + 'burro', + 'burrs', + 'burry', + 'bursa', + 'burse', + 'busby', + 'buses', + 'busks', + 'busky', + 'bussu', + 'busti', + 'busts', + 'busty', + 'buteo', + 'butes', + 'butle', + 'butoh', + 'butts', + 'butty', + 'butut', + 'butyl', + 'buzzy', + 'bwana', + 'bwazi', + 'byded', + 'bydes', + 'byked', + 'bykes', + 'byres', + 'byrls', + 'byssi', + 'bytes', + 'byway', + 'caaed', + 'cabas', + 'caber', + 'cabob', + 'caboc', + 'cabre', + 'cacas', + 'cacks', + 'cacky', + 'cadee', + 'cades', + 'cadge', + 'cadgy', + 'cadie', + 'cadis', + 'cadre', + 'caeca', + 'caese', + 'cafes', + 'caffs', + 'caged', + 'cager', + 'cages', + 'cagot', + 'cahow', + 'caids', + 'cains', + 'caird', + 'cajon', + 'cajun', + 'caked', + 'cakes', + 'cakey', + 'calfs', + 'calid', + 'calif', + 'calix', + 'calks', + 'calla', + 'calls', + 'calms', + 'calmy', + 'calos', + 'calpa', + 'calps', + 'calve', + 'calyx', + 'caman', + 'camas', + 'cames', + 'camis', + 'camos', + 'campi', + 'campo', + 'camps', + 'campy', + 'camus', + 'caned', + 'caneh', + 'caner', + 'canes', + 'cangs', + 'canid', + 'canna', + 'canns', + 'canso', + 'canst', + 'canto', + 'cants', + 'canty', + 'capas', + 'caped', + 'capes', + 'capex', + 'caphs', + 'capiz', + 'caple', + 'capon', + 'capos', + 'capot', + 'capri', + 'capul', + 'carap', + 'carbo', + 'carbs', + 'carby', + 'cardi', + 'cards', + 'cardy', + 'cared', + 'carer', + 'cares', + 'caret', + 'carex', + 'carks', + 'carle', + 'carls', + 'carns', + 'carny', + 'carob', + 'carom', + 'caron', + 'carpi', + 'carps', + 'carrs', + 'carse', + 'carta', + 'carte', + 'carts', + 'carvy', + 'casas', + 'casco', + 'cased', + 'cases', + 'casks', + 'casky', + 'casts', + 'casus', + 'cates', + 'cauda', + 'cauks', + 'cauld', + 'cauls', + 'caums', + 'caups', + 'cauri', + 'causa', + 'cavas', + 'caved', + 'cavel', + 'caver', + 'caves', + 'cavie', + 'cawed', + 'cawks', + 'caxon', + 'ceaze', + 'cebid', + 'cecal', + 'cecum', + 'ceded', + 'ceder', + 'cedes', + 'cedis', + 'ceiba', + 'ceili', + 'ceils', + 'celeb', + 'cella', + 'celli', + 'cells', + 'celom', + 'celts', + 'cense', + 'cento', + 'cents', + 'centu', + 'ceorl', + 'cepes', + 'cerci', + 'cered', + 'ceres', + 'cerge', + 'ceria', + 'ceric', + 'cerne', + 'ceroc', + 'ceros', + 'certs', + 'certy', + 'cesse', + 'cesta', + 'cesti', + 'cetes', + 'cetyl', + 'cezve', + 'chace', + 'chack', + 'chaco', + 'chado', + 'chads', + 'chaft', + 'chais', + 'chals', + 'chams', + 'chana', + 'chang', + 'chank', + 'chape', + 'chaps', + 'chapt', + 'chara', + 'chare', + 'chark', + 'charr', + 'chars', + 'chary', + 'chats', + 'chave', + 'chavs', + 'chawk', + 'chaws', + 'chaya', + 'chays', + 'cheep', + 'chefs', + 'cheka', + 'chela', + 'chelp', + 'chemo', + 'chems', + 'chere', + 'chert', + 'cheth', + 'chevy', + 'chews', + 'chewy', + 'chiao', + 'chias', + 'chibs', + 'chica', + 'chich', + 'chico', + 'chics', + 'chiel', + 'chiks', + 'chile', + 'chimb', + 'chimo', + 'chimp', + 'chine', + 'ching', + 'chink', + 'chino', + 'chins', + 'chips', + 'chirk', + 'chirl', + 'chirm', + 'chiro', + 'chirr', + 'chirt', + 'chiru', + 'chits', + 'chive', + 'chivs', + 'chivy', + 'chizz', + 'choco', + 'chocs', + 'chode', + 'chogs', + 'choil', + 'choko', + 'choky', + 'chola', + 'choli', + 'cholo', + 'chomp', + 'chons', + 'choof', + 'chook', + 'choom', + 'choon', + 'chops', + 'chota', + 'chott', + 'chout', + 'choux', + 'chowk', + 'chows', + 'chubs', + 'chufa', + 'chuff', + 'chugs', + 'chums', + 'churl', + 'churr', + 'chuse', + 'chuts', + 'chyle', + 'chyme', + 'chynd', + 'cibol', + 'cided', + 'cides', + 'ciels', + 'ciggy', + 'cilia', + 'cills', + 'cimar', + 'cimex', + 'cinct', + 'cines', + 'cinqs', + 'cions', + 'cippi', + 'circs', + 'cires', + 'cirls', + 'cirri', + 'cisco', + 'cissy', + 'cists', + 'cital', + 'cited', + 'citer', + 'cites', + 'cives', + 'civet', + 'civie', + 'civvy', + 'clach', + 'clade', + 'clads', + 'claes', + 'clags', + 'clame', + 'clams', + 'clans', + 'claps', + 'clapt', + 'claro', + 'clart', + 'clary', + 'clast', + 'clats', + 'claut', + 'clave', + 'clavi', + 'claws', + 'clays', + 'cleck', + 'cleek', + 'cleep', + 'clefs', + 'clegs', + 'cleik', + 'clems', + 'clepe', + 'clept', + 'cleve', + 'clews', + 'clied', + 'clies', + 'clift', + 'clime', + 'cline', + 'clint', + 'clipe', + 'clips', + 'clipt', + 'clits', + 'cloam', + 'clods', + 'cloff', + 'clogs', + 'cloke', + 'clomb', + 'clomp', + 'clonk', + 'clons', + 'cloop', + 'cloot', + 'clops', + 'clote', + 'clots', + 'clour', + 'clous', + 'clows', + 'cloye', + 'cloys', + 'cloze', + 'clubs', + 'clues', + 'cluey', + 'clunk', + 'clype', + 'cnida', + 'coact', + 'coady', + 'coala', + 'coals', + 'coaly', + 'coapt', + 'coarb', + 'coate', + 'coati', + 'coats', + 'cobbs', + 'cobby', + 'cobia', + 'coble', + 'cobza', + 'cocas', + 'cocci', + 'cocco', + 'cocks', + 'cocky', + 'cocos', + 'codas', + 'codec', + 'coded', + 'coden', + 'coder', + 'codes', + 'codex', + 'codon', + 'coeds', + 'coffs', + 'cogie', + 'cogon', + 'cogue', + 'cohab', + 'cohen', + 'cohoe', + 'cohog', + 'cohos', + 'coifs', + 'coign', + 'coils', + 'coins', + 'coirs', + 'coits', + 'coked', + 'cokes', + 'colas', + 'colby', + 'colds', + 'coled', + 'coles', + 'coley', + 'colic', + 'colin', + 'colls', + 'colly', + 'colog', + 'colts', + 'colza', + 'comae', + 'comal', + 'comas', + 'combe', + 'combi', + 'combo', + 'combs', + 'comby', + 'comer', + 'comes', + 'comix', + 'commo', + 'comms', + 'commy', + 'compo', + 'comps', + 'compt', + 'comte', + 'comus', + 'coned', + 'cones', + 'coney', + 'confs', + 'conga', + 'conge', + 'congo', + 'conia', + 'conin', + 'conks', + 'conky', + 'conne', + 'conns', + 'conte', + 'conto', + 'conus', + 'convo', + 'cooch', + 'cooed', + 'cooee', + 'cooer', + 'cooey', + 'coofs', + 'cooks', + 'cooky', + 'cools', + 'cooly', + 'coomb', + 'cooms', + 'coomy', + 'coons', + 'coops', + 'coopt', + 'coost', + 'coots', + 'cooze', + 'copal', + 'copay', + 'coped', + 'copen', + 'coper', + 'copes', + 'coppy', + 'copra', + 'copsy', + 'coqui', + 'coram', + 'corbe', + 'corby', + 'cords', + 'cored', + 'cores', + 'corey', + 'corgi', + 'coria', + 'corks', + 'corky', + 'corms', + 'corni', + 'corno', + 'corns', + 'cornu', + 'corps', + 'corse', + 'corso', + 'cosec', + 'cosed', + 'coses', + 'coset', + 'cosey', + 'cosie', + 'costa', + 'coste', + 'costs', + 'cotan', + 'coted', + 'cotes', + 'coths', + 'cotta', + 'cotts', + 'coude', + 'coups', + 'courb', + 'courd', + 'coure', + 'cours', + 'couta', + 'couth', + 'coved', + 'coves', + 'covin', + 'cowal', + 'cowan', + 'cowed', + 'cowks', + 'cowls', + 'cowps', + 'cowry', + 'coxae', + 'coxal', + 'coxed', + 'coxes', + 'coxib', + 'coyau', + 'coyed', + 'coyer', + 'coypu', + 'cozed', + 'cozen', + 'cozes', + 'cozey', + 'cozie', + 'craal', + 'crabs', + 'crags', + 'craic', + 'craig', + 'crake', + 'crame', + 'crams', + 'crans', + 'crape', + 'craps', + 'crapy', + 'crare', + 'craws', + 'crays', + 'creds', + 'creel', + 'crees', + 'crems', + 'crena', + 'creps', + 'crepy', + 'crewe', + 'crews', + 'crias', + 'cribs', + 'cries', + 'crims', + 'crine', + 'crios', + 'cripe', + 'crips', + 'crise', + 'crith', + 'crits', + 'croci', + 'crocs', + 'croft', + 'crogs', + 'cromb', + 'crome', + 'cronk', + 'crons', + 'crool', + 'croon', + 'crops', + 'crore', + 'crost', + 'crout', + 'crows', + 'croze', + 'cruck', + 'crudo', + 'cruds', + 'crudy', + 'crues', + 'cruet', + 'cruft', + 'crunk', + 'cruor', + 'crura', + 'cruse', + 'crusy', + 'cruve', + 'crwth', + 'cryer', + 'ctene', + 'cubby', + 'cubeb', + 'cubed', + 'cuber', + 'cubes', + 'cubit', + 'cuddy', + 'cuffo', + 'cuffs', + 'cuifs', + 'cuing', + 'cuish', + 'cuits', + 'cukes', + 'culch', + 'culet', + 'culex', + 'culls', + 'cully', + 'culms', + 'culpa', + 'culti', + 'cults', + 'culty', + 'cumec', + 'cundy', + 'cunei', + 'cunit', + 'cunts', + 'cupel', + 'cupid', + 'cuppa', + 'cuppy', + 'curat', + 'curbs', + 'curch', + 'curds', + 'curdy', + 'cured', + 'curer', + 'cures', + 'curet', + 'curfs', + 'curia', + 'curie', + 'curli', + 'curls', + 'curns', + 'curny', + 'currs', + 'cursi', + 'curst', + 'cusec', + 'cushy', + 'cusks', + 'cusps', + 'cuspy', + 'cusso', + 'cusum', + 'cutch', + 'cuter', + 'cutes', + 'cutey', + 'cutin', + 'cutis', + 'cutto', + 'cutty', + 'cutup', + 'cuvee', + 'cuzes', + 'cwtch', + 'cyano', + 'cyans', + 'cycad', + 'cycas', + 'cyclo', + 'cyder', + 'cylix', + 'cymae', + 'cymar', + 'cymas', + 'cymes', + 'cymol', + 'cysts', + 'cytes', + 'cyton', + 'czars', + 'daals', + 'dabba', + 'daces', + 'dacha', + 'dacks', + 'dadah', + 'dadas', + 'dados', + 'daffs', + 'daffy', + 'dagga', + 'daggy', + 'dagos', + 'dahls', + 'daiko', + 'daine', + 'daint', + 'daker', + 'daled', + 'dales', + 'dalis', + 'dalle', + 'dalts', + 'daman', + 'damar', + 'dames', + 'damme', + 'damns', + 'damps', + 'dampy', + 'dancy', + 'dangs', + 'danio', + 'danks', + 'danny', + 'dants', + 'daraf', + 'darbs', + 'darcy', + 'dared', + 'darer', + 'dares', + 'darga', + 'dargs', + 'daric', + 'daris', + 'darks', + 'darky', + 'darns', + 'darre', + 'darts', + 'darzi', + 'dashi', + 'dashy', + 'datal', + 'dated', + 'dater', + 'dates', + 'datos', + 'datto', + 'daube', + 'daubs', + 'dauby', + 'dauds', + 'dault', + 'daurs', + 'dauts', + 'daven', + 'davit', + 'dawah', + 'dawds', + 'dawed', + 'dawen', + 'dawks', + 'dawns', + 'dawts', + 'dayan', + 'daych', + 'daynt', + 'dazed', + 'dazer', + 'dazes', + 'deads', + 'deair', + 'deals', + 'deans', + 'deare', + 'dearn', + 'dears', + 'deary', + 'deash', + 'deave', + 'deaws', + 'deawy', + 'debag', + 'debby', + 'debel', + 'debes', + 'debts', + 'debud', + 'debur', + 'debus', + 'debye', + 'decad', + 'decaf', + 'decan', + 'decko', + 'decks', + 'decos', + 'dedal', + 'deeds', + 'deedy', + 'deely', + 'deems', + 'deens', + 'deeps', + 'deere', + 'deers', + 'deets', + 'deeve', + 'deevs', + 'defat', + 'deffo', + 'defis', + 'defog', + 'degas', + 'degum', + 'degus', + 'deice', + 'deids', + 'deify', + 'deils', + 'deism', + 'deist', + 'deked', + 'dekes', + 'dekko', + 'deled', + 'deles', + 'delfs', + 'delft', + 'delis', + 'dells', + 'delly', + 'delos', + 'delph', + 'delts', + 'deman', + 'demes', + 'demic', + 'demit', + 'demob', + 'demoi', + 'demos', + 'dempt', + 'denar', + 'denay', + 'dench', + 'denes', + 'denet', + 'denis', + 'dents', + 'deoxy', + 'derat', + 'deray', + 'dered', + 'deres', + 'derig', + 'derma', + 'derms', + 'derns', + 'derny', + 'deros', + 'derro', + 'derry', + 'derth', + 'dervs', + 'desex', + 'deshi', + 'desis', + 'desks', + 'desse', + 'devas', + 'devel', + 'devis', + 'devon', + 'devos', + 'devot', + 'dewan', + 'dewar', + 'dewax', + 'dewed', + 'dexes', + 'dexie', + 'dhaba', + 'dhaks', + 'dhals', + 'dhikr', + 'dhobi', + 'dhole', + 'dholl', + 'dhols', + 'dhoti', + 'dhows', + 'dhuti', + 'diact', + 'dials', + 'diane', + 'diazo', + 'dibbs', + 'diced', + 'dicer', + 'dices', + 'dicht', + 'dicks', + 'dicky', + 'dicot', + 'dicta', + 'dicts', + 'dicty', + 'diddy', + 'didie', + 'didos', + 'didst', + 'diebs', + 'diels', + 'diene', + 'diets', + 'diffs', + 'dight', + 'dikas', + 'diked', + 'diker', + 'dikes', + 'dikey', + 'dildo', + 'dilli', + 'dills', + 'dimbo', + 'dimer', + 'dimes', + 'dimps', + 'dinar', + 'dined', + 'dines', + 'dinge', + 'dings', + 'dinic', + 'dinks', + 'dinky', + 'dinna', + 'dinos', + 'dints', + 'diols', + 'diota', + 'dippy', + 'dipso', + 'diram', + 'direr', + 'dirke', + 'dirks', + 'dirls', + 'dirts', + 'disas', + 'disci', + 'discs', + 'dishy', + 'disks', + 'disme', + 'dital', + 'ditas', + 'dited', + 'dites', + 'ditsy', + 'ditts', + 'ditzy', + 'divan', + 'divas', + 'dived', + 'dives', + 'divis', + 'divna', + 'divos', + 'divot', + 'divvy', + 'diwan', + 'dixie', + 'dixit', + 'diyas', + 'dizen', + 'djinn', + 'djins', + 'doabs', + 'doats', + 'dobby', + 'dobes', + 'dobie', + 'dobla', + 'dobra', + 'dobro', + 'docht', + 'docks', + 'docos', + 'docus', + 'doddy', + 'dodos', + 'doeks', + 'doers', + 'doest', + 'doeth', + 'doffs', + 'dogan', + 'doges', + 'dogey', + 'doggo', + 'doggy', + 'dogie', + 'dohyo', + 'doilt', + 'doily', + 'doits', + 'dojos', + 'dolce', + 'dolci', + 'doled', + 'doles', + 'dolia', + 'dolls', + 'dolma', + 'dolor', + 'dolos', + 'dolts', + 'domal', + 'domed', + 'domes', + 'domic', + 'donah', + 'donas', + 'donee', + 'doner', + 'donga', + 'dongs', + 'donko', + 'donna', + 'donne', + 'donny', + 'donsy', + 'doobs', + 'dooce', + 'doody', + 'dooks', + 'doole', + 'dools', + 'dooly', + 'dooms', + 'doomy', + 'doona', + 'doorn', + 'doors', + 'doozy', + 'dopas', + 'doped', + 'doper', + 'dopes', + 'dorad', + 'dorba', + 'dorbs', + 'doree', + 'dores', + 'doric', + 'doris', + 'dorks', + 'dorky', + 'dorms', + 'dormy', + 'dorps', + 'dorrs', + 'dorsa', + 'dorse', + 'dorts', + 'dorty', + 'dosai', + 'dosas', + 'dosed', + 'doseh', + 'doser', + 'doses', + 'dosha', + 'dotal', + 'doted', + 'doter', + 'dotes', + 'dotty', + 'douar', + 'douce', + 'doucs', + 'douks', + 'doula', + 'douma', + 'doums', + 'doups', + 'doura', + 'douse', + 'douts', + 'doved', + 'doven', + 'dover', + 'doves', + 'dovie', + 'dowar', + 'dowds', + 'dowed', + 'dower', + 'dowie', + 'dowle', + 'dowls', + 'dowly', + 'downa', + 'downs', + 'dowps', + 'dowse', + 'dowts', + 'doxed', + 'doxes', + 'doxie', + 'doyen', + 'doyly', + 'dozed', + 'dozer', + 'dozes', + 'drabs', + 'drack', + 'draco', + 'draff', + 'drags', + 'drail', + 'drams', + 'drant', + 'draps', + 'drats', + 'drave', + 'draws', + 'drays', + 'drear', + 'dreck', + 'dreed', + 'dreer', + 'drees', + 'dregs', + 'dreks', + 'drent', + 'drere', + 'drest', + 'dreys', + 'dribs', + 'drice', + 'dries', + 'drily', + 'drips', + 'dript', + 'droid', + 'droil', + 'droke', + 'drole', + 'drome', + 'drony', + 'droob', + 'droog', + 'drook', + 'drops', + 'dropt', + 'drouk', + 'drows', + 'drubs', + 'drugs', + 'drums', + 'drupe', + 'druse', + 'drusy', + 'druxy', + 'dryad', + 'dryas', + 'dsobo', + 'dsomo', + 'duads', + 'duals', + 'duans', + 'duars', + 'dubbo', + 'ducal', + 'ducat', + 'duces', + 'ducks', + 'ducky', + 'ducts', + 'duddy', + 'duded', + 'dudes', + 'duels', + 'duets', + 'duett', + 'duffs', + 'dufus', + 'duing', + 'duits', + 'dukas', + 'duked', + 'dukes', + 'dukka', + 'dulce', + 'dules', + 'dulia', + 'dulls', + 'dulse', + 'dumas', + 'dumbo', + 'dumbs', + 'dumka', + 'dumky', + 'dumps', + 'dunam', + 'dunch', + 'dunes', + 'dungs', + 'dungy', + 'dunks', + 'dunno', + 'dunny', + 'dunsh', + 'dunts', + 'duomi', + 'duomo', + 'duped', + 'duper', + 'dupes', + 'duple', + 'duply', + 'duppy', + 'dural', + 'duras', + 'dured', + 'dures', + 'durgy', + 'durns', + 'duroc', + 'duros', + 'duroy', + 'durra', + 'durrs', + 'durry', + 'durst', + 'durum', + 'durzi', + 'dusks', + 'dusts', + 'duxes', + 'dwaal', + 'dwale', + 'dwalm', + 'dwams', + 'dwang', + 'dwaum', + 'dweeb', + 'dwile', + 'dwine', + 'dyads', + 'dyers', + 'dyked', + 'dykes', + 'dykey', + 'dykon', + 'dynel', + 'dynes', + 'dzhos', + 'eagre', + 'ealed', + 'eales', + 'eaned', + 'eards', + 'eared', + 'earls', + 'earns', + 'earnt', + 'earst', + 'eased', + 'easer', + 'eases', + 'easle', + 'easts', + 'eathe', + 'eaved', + 'eaves', + 'ebbed', + 'ebbet', + 'ebons', + 'ebook', + 'ecads', + 'eched', + 'eches', + 'echos', + 'ecrus', + 'edema', + 'edged', + 'edger', + 'edges', + 'edile', + 'edits', + 'educe', + 'educt', + 'eejit', + 'eensy', + 'eeven', + 'eevns', + 'effed', + 'egads', + 'egers', + 'egest', + 'eggar', + 'egged', + 'egger', + 'egmas', + 'ehing', + 'eider', + 'eidos', + 'eigne', + 'eiked', + 'eikon', + 'eilds', + 'eisel', + 'ejido', + 'ekkas', + 'elain', + 'eland', + 'elans', + 'elchi', + 'eldin', + 'elemi', + 'elfed', + 'eliad', + 'elint', + 'elmen', + 'eloge', + 'elogy', + 'eloin', + 'elops', + 'elpee', + 'elsin', + 'elute', + 'elvan', + 'elven', + 'elver', + 'elves', + 'emacs', + 'embar', + 'embay', + 'embog', + 'embow', + 'embox', + 'embus', + 'emeer', + 'emend', + 'emerg', + 'emery', + 'emeus', + 'emics', + 'emirs', + 'emits', + 'emmas', + 'emmer', + 'emmet', + 'emmew', + 'emmys', + 'emoji', + 'emong', + 'emote', + 'emove', + 'empts', + 'emule', + 'emure', + 'emyde', + 'emyds', + 'enarm', + 'enate', + 'ended', + 'ender', + 'endew', + 'endue', + 'enews', + 'enfix', + 'eniac', + 'enlit', + 'enmew', + 'ennog', + 'enoki', + 'enols', + 'enorm', + 'enows', + 'enrol', + 'ensew', + 'ensky', + 'entia', + 'enure', + 'enurn', + 'envoi', + 'enzym', + 'eorls', + 'eosin', + 'epact', + 'epees', + 'ephah', + 'ephas', + 'ephod', + 'ephor', + 'epics', + 'epode', + 'epopt', + 'epris', + 'eques', + 'equid', + 'erbia', + 'erevs', + 'ergon', + 'ergos', + 'ergot', + 'erhus', + 'erica', + 'erick', + 'erics', + 'ering', + 'erned', + 'ernes', + 'erose', + 'erred', + 'erses', + 'eruct', + 'erugo', + 'eruvs', + 'erven', + 'ervil', + 'escar', + 'escot', + 'esile', + 'eskar', + 'esker', + 'esnes', + 'esses', + 'estoc', + 'estop', + 'estro', + 'etage', + 'etape', + 'etats', + 'etens', + 'ethal', + 'ethne', + 'ethyl', + 'etics', + 'etnas', + 'ettin', + 'ettle', + 'etuis', + 'etwee', + 'etyma', + 'eughs', + 'euked', + 'eupad', + 'euros', + 'eusol', + 'evens', + 'evert', + 'evets', + 'evhoe', + 'evils', + 'evite', + 'evohe', + 'ewers', + 'ewest', + 'ewhow', + 'ewked', + 'exams', + 'exeat', + 'execs', + 'exeem', + 'exeme', + 'exfil', + 'exies', + 'exine', + 'exing', + 'exits', + 'exode', + 'exome', + 'exons', + 'expat', + 'expos', + 'exude', + 'exuls', + 'exurb', + 'eyass', + 'eyers', + 'eyots', + 'eyras', + 'eyres', + 'eyrie', + 'eyrir', + 'ezine', + 'fabby', + 'faced', + 'facer', + 'faces', + 'facia', + 'facta', + 'facts', + 'faddy', + 'faded', + 'fader', + 'fades', + 'fadge', + 'fados', + 'faena', + 'faery', + 'faffs', + 'faffy', + 'faggy', + 'fagin', + 'fagot', + 'faiks', + 'fails', + 'faine', + 'fains', + 'fairs', + 'faked', + 'faker', + 'fakes', + 'fakey', + 'fakie', + 'fakir', + 'falaj', + 'falls', + 'famed', + 'fames', + 'fanal', + 'fands', + 'fanes', + 'fanga', + 'fango', + 'fangs', + 'fanks', + 'fanon', + 'fanos', + 'fanum', + 'faqir', + 'farad', + 'farci', + 'farcy', + 'fards', + 'fared', + 'farer', + 'fares', + 'farle', + 'farls', + 'farms', + 'faros', + 'farro', + 'farse', + 'farts', + 'fasci', + 'fasti', + 'fasts', + 'fated', + 'fates', + 'fatly', + 'fatso', + 'fatwa', + 'faugh', + 'fauld', + 'fauns', + 'faurd', + 'fauts', + 'fauve', + 'favas', + 'favel', + 'faver', + 'faves', + 'favus', + 'fawns', + 'fawny', + 'faxed', + 'faxes', + 'fayed', + 'fayer', + 'fayne', + 'fayre', + 'fazed', + 'fazes', + 'feals', + 'feare', + 'fears', + 'feart', + 'fease', + 'feats', + 'feaze', + 'feces', + 'fecht', + 'fecit', + 'fecks', + 'fedex', + 'feebs', + 'feeds', + 'feels', + 'feens', + 'feers', + 'feese', + 'feeze', + 'fehme', + 'feint', + 'feist', + 'felch', + 'felid', + 'fells', + 'felly', + 'felts', + 'felty', + 'femal', + 'femes', + 'femmy', + 'fends', + 'fendy', + 'fenis', + 'fenks', + 'fenny', + 'fents', + 'feods', + 'feoff', + 'ferer', + 'feres', + 'feria', + 'ferly', + 'fermi', + 'ferms', + 'ferns', + 'ferny', + 'fesse', + 'festa', + 'fests', + 'festy', + 'fetas', + 'feted', + 'fetes', + 'fetor', + 'fetta', + 'fetts', + 'fetwa', + 'feuar', + 'feuds', + 'feued', + 'feyed', + 'feyer', + 'feyly', + 'fezes', + 'fezzy', + 'fiars', + 'fiats', + 'fibro', + 'fices', + 'fiche', + 'fichu', + 'ficin', + 'ficos', + 'fides', + 'fidge', + 'fidos', + 'fiefs', + 'fient', + 'fiere', + 'fiers', + 'fiest', + 'fifed', + 'fifer', + 'fifes', + 'fifis', + 'figgy', + 'figos', + 'fiked', + 'fikes', + 'filar', + 'filch', + 'filed', + 'files', + 'filii', + 'filks', + 'fille', + 'fillo', + 'fills', + 'filmi', + 'films', + 'filos', + 'filum', + 'finca', + 'finds', + 'fined', + 'fines', + 'finis', + 'finks', + 'finny', + 'finos', + 'fiord', + 'fiqhs', + 'fique', + 'fired', + 'firer', + 'fires', + 'firie', + 'firks', + 'firms', + 'firns', + 'firry', + 'firth', + 'fiscs', + 'fisks', + 'fists', + 'fisty', + 'fitch', + 'fitly', + 'fitna', + 'fitte', + 'fitts', + 'fiver', + 'fives', + 'fixed', + 'fixes', + 'fixit', + 'fjeld', + 'flabs', + 'flaff', + 'flags', + 'flaks', + 'flamm', + 'flams', + 'flamy', + 'flane', + 'flans', + 'flaps', + 'flary', + 'flats', + 'flava', + 'flawn', + 'flaws', + 'flawy', + 'flaxy', + 'flays', + 'fleam', + 'fleas', + 'fleek', + 'fleer', + 'flees', + 'flegs', + 'fleme', + 'fleur', + 'flews', + 'flexi', + 'flexo', + 'fleys', + 'flics', + 'flied', + 'flies', + 'flimp', + 'flims', + 'flips', + 'flirs', + 'flisk', + 'flite', + 'flits', + 'flitt', + 'flobs', + 'flocs', + 'floes', + 'flogs', + 'flong', + 'flops', + 'flors', + 'flory', + 'flosh', + 'flota', + 'flote', + 'flows', + 'flubs', + 'flued', + 'flues', + 'fluey', + 'fluky', + 'flump', + 'fluor', + 'flurr', + 'fluty', + 'fluyt', + 'flyby', + 'flype', + 'flyte', + 'foals', + 'foams', + 'foehn', + 'fogey', + 'fogie', + 'fogle', + 'fogou', + 'fohns', + 'foids', + 'foils', + 'foins', + 'folds', + 'foley', + 'folia', + 'folic', + 'folie', + 'folks', + 'folky', + 'fomes', + 'fonda', + 'fonds', + 'fondu', + 'fones', + 'fonly', + 'fonts', + 'foods', + 'foody', + 'fools', + 'foots', + 'footy', + 'foram', + 'forbs', + 'forby', + 'fordo', + 'fords', + 'forel', + 'fores', + 'forex', + 'forks', + 'forky', + 'forme', + 'forms', + 'forts', + 'forza', + 'forze', + 'fossa', + 'fosse', + 'fouat', + 'fouds', + 'fouer', + 'fouet', + 'foule', + 'fouls', + 'fount', + 'fours', + 'fouth', + 'fovea', + 'fowls', + 'fowth', + 'foxed', + 'foxes', + 'foxie', + 'foyle', + 'foyne', + 'frabs', + 'frack', + 'fract', + 'frags', + 'fraim', + 'franc', + 'frape', + 'fraps', + 'frass', + 'frate', + 'frati', + 'frats', + 'fraus', + 'frays', + 'frees', + 'freet', + 'freit', + 'fremd', + 'frena', + 'freon', + 'frere', + 'frets', + 'fribs', + 'frier', + 'fries', + 'frigs', + 'frise', + 'frist', + 'frith', + 'frits', + 'fritt', + 'frize', + 'frizz', + 'froes', + 'frogs', + 'frons', + 'frore', + 'frorn', + 'frory', + 'frosh', + 'frows', + 'frowy', + 'frugs', + 'frump', + 'frush', + 'frust', + 'fryer', + 'fubar', + 'fubby', + 'fubsy', + 'fucks', + 'fucus', + 'fuddy', + 'fudgy', + 'fuels', + 'fuero', + 'fuffs', + 'fuffy', + 'fugal', + 'fuggy', + 'fugie', + 'fugio', + 'fugle', + 'fugly', + 'fugus', + 'fujis', + 'fulls', + 'fumed', + 'fumer', + 'fumes', + 'fumet', + 'fundi', + 'funds', + 'fundy', + 'fungo', + 'fungs', + 'funks', + 'fural', + 'furan', + 'furca', + 'furls', + 'furol', + 'furrs', + 'furth', + 'furze', + 'furzy', + 'fused', + 'fusee', + 'fusel', + 'fuses', + 'fusil', + 'fusks', + 'fusts', + 'fusty', + 'futon', + 'fuzed', + 'fuzee', + 'fuzes', + 'fuzil', + 'fyces', + 'fyked', + 'fykes', + 'fyles', + 'fyrds', + 'fytte', + 'gabba', + 'gabby', + 'gable', + 'gaddi', + 'gades', + 'gadge', + 'gadid', + 'gadis', + 'gadje', + 'gadjo', + 'gadso', + 'gaffs', + 'gaged', + 'gager', + 'gages', + 'gaids', + 'gains', + 'gairs', + 'gaita', + 'gaits', + 'gaitt', + 'gajos', + 'galah', + 'galas', + 'galax', + 'galea', + 'galed', + 'gales', + 'galls', + 'gally', + 'galop', + 'galut', + 'galvo', + 'gamas', + 'gamay', + 'gamba', + 'gambe', + 'gambo', + 'gambs', + 'gamed', + 'games', + 'gamey', + 'gamic', + 'gamin', + 'gamme', + 'gammy', + 'gamps', + 'ganch', + 'gandy', + 'ganef', + 'ganev', + 'gangs', + 'ganja', + 'ganof', + 'gants', + 'gaols', + 'gaped', + 'gaper', + 'gapes', + 'gapos', + 'gappy', + 'garbe', + 'garbo', + 'garbs', + 'garda', + 'gares', + 'garis', + 'garms', + 'garni', + 'garre', + 'garth', + 'garum', + 'gases', + 'gasps', + 'gaspy', + 'gasts', + 'gatch', + 'gated', + 'gater', + 'gates', + 'gaths', + 'gator', + 'gauch', + 'gaucy', + 'gauds', + 'gauje', + 'gault', + 'gaums', + 'gaumy', + 'gaups', + 'gaurs', + 'gauss', + 'gauzy', + 'gavot', + 'gawcy', + 'gawds', + 'gawks', + 'gawps', + 'gawsy', + 'gayal', + 'gazal', + 'gazar', + 'gazed', + 'gazes', + 'gazon', + 'gazoo', + 'geals', + 'geans', + 'geare', + 'gears', + 'geats', + 'gebur', + 'gecks', + 'geeks', + 'geeps', + 'geest', + 'geist', + 'geits', + 'gelds', + 'gelee', + 'gelid', + 'gelly', + 'gelts', + 'gemel', + 'gemma', + 'gemmy', + 'gemot', + 'genal', + 'genas', + 'genes', + 'genet', + 'genic', + 'genii', + 'genip', + 'genny', + 'genoa', + 'genom', + 'genro', + 'gents', + 'genty', + 'genua', + 'genus', + 'geode', + 'geoid', + 'gerah', + 'gerbe', + 'geres', + 'gerle', + 'germs', + 'germy', + 'gerne', + 'gesse', + 'gesso', + 'geste', + 'gests', + 'getas', + 'getup', + 'geums', + 'geyan', + 'geyer', + 'ghast', + 'ghats', + 'ghaut', + 'ghazi', + 'ghees', + 'ghest', + 'ghyll', + 'gibed', + 'gibel', + 'giber', + 'gibes', + 'gibli', + 'gibus', + 'gifts', + 'gigas', + 'gighe', + 'gigot', + 'gigue', + 'gilas', + 'gilds', + 'gilet', + 'gills', + 'gilly', + 'gilpy', + 'gilts', + 'gimel', + 'gimme', + 'gimps', + 'gimpy', + 'ginch', + 'ginge', + 'gings', + 'ginks', + 'ginny', + 'ginzo', + 'gipon', + 'gippo', + 'gippy', + 'girds', + 'girls', + 'girns', + 'giron', + 'giros', + 'girrs', + 'girsh', + 'girts', + 'gismo', + 'gisms', + 'gists', + 'gitch', + 'gites', + 'giust', + 'gived', + 'gives', + 'gizmo', + 'glace', + 'glads', + 'glady', + 'glaik', + 'glair', + 'glams', + 'glans', + 'glary', + 'glaum', + 'glaur', + 'glazy', + 'gleba', + 'glebe', + 'gleby', + 'glede', + 'gleds', + 'gleed', + 'gleek', + 'glees', + 'gleet', + 'gleis', + 'glens', + 'glent', + 'gleys', + 'glial', + 'glias', + 'glibs', + 'gliff', + 'glift', + 'glike', + 'glime', + 'glims', + 'glisk', + 'glits', + 'glitz', + 'gloam', + 'globi', + 'globs', + 'globy', + 'glode', + 'glogg', + 'gloms', + 'gloop', + 'glops', + 'glost', + 'glout', + 'glows', + 'gloze', + 'glued', + 'gluer', + 'glues', + 'gluey', + 'glugs', + 'glume', + 'glums', + 'gluon', + 'glute', + 'gluts', + 'gnarl', + 'gnarr', + 'gnars', + 'gnats', + 'gnawn', + 'gnaws', + 'gnows', + 'goads', + 'goafs', + 'goals', + 'goary', + 'goats', + 'goaty', + 'goban', + 'gobar', + 'gobbi', + 'gobbo', + 'gobby', + 'gobis', + 'gobos', + 'godet', + 'godso', + 'goels', + 'goers', + 'goest', + 'goeth', + 'goety', + 'gofer', + 'goffs', + 'gogga', + 'gogos', + 'goier', + 'gojis', + 'golds', + 'goldy', + 'goles', + 'golfs', + 'golpe', + 'golps', + 'gombo', + 'gomer', + 'gompa', + 'gonch', + 'gonef', + 'gongs', + 'gonia', + 'gonif', + 'gonks', + 'gonna', + 'gonof', + 'gonys', + 'gonzo', + 'gooby', + 'goods', + 'goofs', + 'googs', + 'gooks', + 'gooky', + 'goold', + 'gools', + 'gooly', + 'goons', + 'goony', + 'goops', + 'goopy', + 'goors', + 'goory', + 'goosy', + 'gopak', + 'gopik', + 'goral', + 'goras', + 'gored', + 'gores', + 'goris', + 'gorms', + 'gormy', + 'gorps', + 'gorse', + 'gorsy', + 'gosht', + 'gosse', + 'gotch', + 'goths', + 'gothy', + 'gotta', + 'gouch', + 'gouks', + 'goura', + 'gouts', + 'gouty', + 'gowan', + 'gowds', + 'gowfs', + 'gowks', + 'gowls', + 'gowns', + 'goxes', + 'goyim', + 'goyle', + 'graal', + 'grabs', + 'grads', + 'graff', + 'graip', + 'grama', + 'grame', + 'gramp', + 'grams', + 'grana', + 'grans', + 'grapy', + 'gravs', + 'grays', + 'grebe', + 'grebo', + 'grece', + 'greek', + 'grees', + 'grege', + 'grego', + 'grein', + 'grens', + 'grese', + 'greve', + 'grews', + 'greys', + 'grice', + 'gride', + 'grids', + 'griff', + 'grift', + 'grigs', + 'grike', + 'grins', + 'griot', + 'grips', + 'gript', + 'gripy', + 'grise', + 'grist', + 'grisy', + 'grith', + 'grits', + 'grize', + 'groat', + 'grody', + 'grogs', + 'groks', + 'groma', + 'grone', + 'groof', + 'grosz', + 'grots', + 'grouf', + 'grovy', + 'grows', + 'grrls', + 'grrrl', + 'grubs', + 'grued', + 'grues', + 'grufe', + 'grume', + 'grump', + 'grund', + 'gryce', + 'gryde', + 'gryke', + 'grype', + 'grypt', + 'guaco', + 'guana', + 'guano', + 'guans', + 'guars', + 'gucks', + 'gucky', + 'gudes', + 'guffs', + 'gugas', + 'guids', + 'guimp', + 'guiro', + 'gulag', + 'gular', + 'gulas', + 'gules', + 'gulet', + 'gulfs', + 'gulfy', + 'gulls', + 'gulph', + 'gulps', + 'gulpy', + 'gumma', + 'gummi', + 'gumps', + 'gundy', + 'gunge', + 'gungy', + 'gunks', + 'gunky', + 'gunny', + 'guqin', + 'gurdy', + 'gurge', + 'gurls', + 'gurly', + 'gurns', + 'gurry', + 'gursh', + 'gurus', + 'gushy', + 'gusla', + 'gusle', + 'gusli', + 'gussy', + 'gusts', + 'gutsy', + 'gutta', + 'gutty', + 'guyed', + 'guyle', + 'guyot', + 'guyse', + 'gwine', + 'gyals', + 'gyans', + 'gybed', + 'gybes', + 'gyeld', + 'gymps', + 'gynae', + 'gynie', + 'gynny', + 'gynos', + 'gyoza', + 'gypos', + 'gyppo', + 'gyppy', + 'gyral', + 'gyred', + 'gyres', + 'gyron', + 'gyros', + 'gyrus', + 'gytes', + 'gyved', + 'gyves', + 'haafs', + 'haars', + 'hable', + 'habus', + 'hacek', + 'hacks', + 'hadal', + 'haded', + 'hades', + 'hadji', + 'hadst', + 'haems', + 'haets', + 'haffs', + 'hafiz', + 'hafts', + 'haggs', + 'hahas', + 'haick', + 'haika', + 'haiks', + 'haiku', + 'hails', + 'haily', + 'hains', + 'haint', + 'hairs', + 'haith', + 'hajes', + 'hajis', + 'hajji', + 'hakam', + 'hakas', + 'hakea', + 'hakes', + 'hakim', + 'hakus', + 'halal', + 'haled', + 'haler', + 'hales', + 'halfa', + 'halfs', + 'halid', + 'hallo', + 'halls', + 'halma', + 'halms', + 'halon', + 'halos', + 'halse', + 'halts', + 'halva', + 'halwa', + 'hamal', + 'hamba', + 'hamed', + 'hames', + 'hammy', + 'hamza', + 'hanap', + 'hance', + 'hanch', + 'hands', + 'hangi', + 'hangs', + 'hanks', + 'hanky', + 'hansa', + 'hanse', + 'hants', + 'haole', + 'haoma', + 'hapax', + 'haply', + 'happi', + 'hapus', + 'haram', + 'hards', + 'hared', + 'hares', + 'harim', + 'harks', + 'harls', + 'harms', + 'harns', + 'haros', + 'harps', + 'harts', + 'hashy', + 'hasks', + 'hasps', + 'hasta', + 'hated', + 'hates', + 'hatha', + 'hauds', + 'haufs', + 'haugh', + 'hauld', + 'haulm', + 'hauls', + 'hault', + 'hauns', + 'hause', + 'haver', + 'haves', + 'hawed', + 'hawks', + 'hawms', + 'hawse', + 'hayed', + 'hayer', + 'hayey', + 'hayle', + 'hazan', + 'hazed', + 'hazer', + 'hazes', + 'heads', + 'heald', + 'heals', + 'heame', + 'heaps', + 'heapy', + 'heare', + 'hears', + 'heast', + 'heats', + 'heben', + 'hebes', + 'hecht', + 'hecks', + 'heder', + 'hedgy', + 'heeds', + 'heedy', + 'heels', + 'heeze', + 'hefte', + 'hefts', + 'heids', + 'heigh', + 'heils', + 'heirs', + 'hejab', + 'hejra', + 'heled', + 'heles', + 'helio', + 'hells', + 'helms', + 'helos', + 'helot', + 'helps', + 'helve', + 'hemal', + 'hemes', + 'hemic', + 'hemin', + 'hemps', + 'hempy', + 'hench', + 'hends', + 'henge', + 'henna', + 'henny', + 'henry', + 'hents', + 'hepar', + 'herbs', + 'herby', + 'herds', + 'heres', + 'herls', + 'herma', + 'herms', + 'herns', + 'heros', + 'herry', + 'herse', + 'hertz', + 'herye', + 'hesps', + 'hests', + 'hetes', + 'heths', + 'heuch', + 'heugh', + 'hevea', + 'hewed', + 'hewer', + 'hewgh', + 'hexad', + 'hexed', + 'hexer', + 'hexes', + 'hexyl', + 'heyed', + 'hiant', + 'hicks', + 'hided', + 'hider', + 'hides', + 'hiems', + 'highs', + 'hight', + 'hijab', + 'hijra', + 'hiked', + 'hiker', + 'hikes', + 'hikoi', + 'hilar', + 'hilch', + 'hillo', + 'hills', + 'hilts', + 'hilum', + 'hilus', + 'himbo', + 'hinau', + 'hinds', + 'hings', + 'hinky', + 'hinny', + 'hints', + 'hiois', + 'hiply', + 'hired', + 'hiree', + 'hirer', + 'hires', + 'hissy', + 'hists', + 'hithe', + 'hived', + 'hiver', + 'hives', + 'hizen', + 'hoaed', + 'hoagy', + 'hoars', + 'hoary', + 'hoast', + 'hobos', + 'hocks', + 'hocus', + 'hodad', + 'hodja', + 'hoers', + 'hogan', + 'hogen', + 'hoggs', + 'hoghs', + 'hohed', + 'hoick', + 'hoied', + 'hoiks', + 'hoing', + 'hoise', + 'hokas', + 'hoked', + 'hokes', + 'hokey', + 'hokis', + 'hokku', + 'hokum', + 'holds', + 'holed', + 'holes', + 'holey', + 'holks', + 'holla', + 'hollo', + 'holme', + 'holms', + 'holon', + 'holos', + 'holts', + 'homas', + 'homed', + 'homes', + 'homey', + 'homie', + 'homme', + 'homos', + 'honan', + 'honda', + 'honds', + 'honed', + 'honer', + 'hones', + 'hongi', + 'hongs', + 'honks', + 'honky', + 'hooch', + 'hoods', + 'hoody', + 'hooey', + 'hoofs', + 'hooka', + 'hooks', + 'hooky', + 'hooly', + 'hoons', + 'hoops', + 'hoord', + 'hoors', + 'hoosh', + 'hoots', + 'hooty', + 'hoove', + 'hopak', + 'hoped', + 'hoper', + 'hopes', + 'hoppy', + 'horah', + 'horal', + 'horas', + 'horis', + 'horks', + 'horme', + 'horns', + 'horst', + 'horsy', + 'hosed', + 'hosel', + 'hosen', + 'hoser', + 'hoses', + 'hosey', + 'hosta', + 'hosts', + 'hotch', + 'hoten', + 'hotty', + 'houff', + 'houfs', + 'hough', + 'houri', + 'hours', + 'houts', + 'hovea', + 'hoved', + 'hoven', + 'hoves', + 'howbe', + 'howes', + 'howff', + 'howfs', + 'howks', + 'howls', + 'howre', + 'howso', + 'hoxed', + 'hoxes', + 'hoyas', + 'hoyed', + 'hoyle', + 'hubby', + 'hucks', + 'hudna', + 'hudud', + 'huers', + 'huffs', + 'huffy', + 'huger', + 'huggy', + 'huhus', + 'huias', + 'hulas', + 'hules', + 'hulks', + 'hulky', + 'hullo', + 'hulls', + 'hully', + 'humas', + 'humfs', + 'humic', + 'humps', + 'humpy', + 'hunks', + 'hunts', + 'hurds', + 'hurls', + 'hurly', + 'hurra', + 'hurst', + 'hurts', + 'hushy', + 'husks', + 'husos', + 'hutia', + 'huzza', + 'huzzy', + 'hwyls', + 'hydra', + 'hyens', + 'hygge', + 'hying', + 'hykes', + 'hylas', + 'hyleg', + 'hyles', + 'hylic', + 'hymns', + 'hynde', + 'hyoid', + 'hyped', + 'hypes', + 'hypha', + 'hyphy', + 'hypos', + 'hyrax', + 'hyson', + 'hythe', + 'iambi', + 'iambs', + 'ibrik', + 'icers', + 'iched', + 'iches', + 'ichor', + 'icier', + 'icker', + 'ickle', + 'icons', + 'ictal', + 'ictic', + 'ictus', + 'idant', + 'ideas', + 'idees', + 'ident', + 'idled', + 'idles', + 'idola', + 'idols', + 'idyls', + 'iftar', + 'igapo', + 'igged', + 'iglus', + 'ihram', + 'ikans', + 'ikats', + 'ikons', + 'ileac', + 'ileal', + 'ileum', + 'ileus', + 'iliad', + 'ilial', + 'ilium', + 'iller', + 'illth', + 'imago', + 'imams', + 'imari', + 'imaum', + 'imbar', + 'imbed', + 'imide', + 'imido', + 'imids', + 'imine', + 'imino', + 'immew', + 'immit', + 'immix', + 'imped', + 'impis', + 'impot', + 'impro', + 'imshi', + 'imshy', + 'inapt', + 'inarm', + 'inbye', + 'incel', + 'incle', + 'incog', + 'incus', + 'incut', + 'indew', + 'india', + 'indie', + 'indol', + 'indow', + 'indri', + 'indue', + 'inerm', + 'infix', + 'infos', + 'infra', + 'ingan', + 'ingle', + 'inion', + 'inked', + 'inker', + 'inkle', + 'inned', + 'innit', + 'inorb', + 'inrun', + 'inset', + 'inspo', + 'intel', + 'intil', + 'intis', + 'intra', + 'inula', + 'inure', + 'inurn', + 'inust', + 'invar', + 'inwit', + 'iodic', + 'iodid', + 'iodin', + 'iotas', + 'ippon', + 'irade', + 'irids', + 'iring', + 'irked', + 'iroko', + 'irone', + 'irons', + 'isbas', + 'ishes', + 'isled', + 'isles', + 'isnae', + 'issei', + 'istle', + 'items', + 'ither', + 'ivied', + 'ivies', + 'ixias', + 'ixnay', + 'ixora', + 'ixtle', + 'izard', + 'izars', + 'izzat', + 'jaaps', + 'jabot', + 'jacal', + 'jacks', + 'jacky', + 'jaded', + 'jades', + 'jafas', + 'jaffa', + 'jagas', + 'jager', + 'jaggs', + 'jaggy', + 'jagir', + 'jagra', + 'jails', + 'jaker', + 'jakes', + 'jakey', + 'jalap', + 'jalop', + 'jambe', + 'jambo', + 'jambs', + 'jambu', + 'james', + 'jammy', + 'jamon', + 'janes', + 'janns', + 'janny', + 'janty', + 'japan', + 'japed', + 'japer', + 'japes', + 'jarks', + 'jarls', + 'jarps', + 'jarta', + 'jarul', + 'jasey', + 'jaspe', + 'jasps', + 'jatos', + 'jauks', + 'jaups', + 'javas', + 'javel', + 'jawan', + 'jawed', + 'jaxie', + 'jeans', + 'jeats', + 'jebel', + 'jedis', + 'jeels', + 'jeely', + 'jeeps', + 'jeers', + 'jeeze', + 'jefes', + 'jeffs', + 'jehad', + 'jehus', + 'jelab', + 'jello', + 'jells', + 'jembe', + 'jemmy', + 'jenny', + 'jeons', + 'jerid', + 'jerks', + 'jerry', + 'jesse', + 'jests', + 'jesus', + 'jetes', + 'jeton', + 'jeune', + 'jewed', + 'jewie', + 'jhala', + 'jiaos', + 'jibba', + 'jibbs', + 'jibed', + 'jiber', + 'jibes', + 'jiffs', + 'jiggy', + 'jigot', + 'jihad', + 'jills', + 'jilts', + 'jimmy', + 'jimpy', + 'jingo', + 'jinks', + 'jinne', + 'jinni', + 'jinns', + 'jirds', + 'jirga', + 'jirre', + 'jisms', + 'jived', + 'jiver', + 'jives', + 'jivey', + 'jnana', + 'jobed', + 'jobes', + 'jocko', + 'jocks', + 'jocky', + 'jocos', + 'jodel', + 'joeys', + 'johns', + 'joins', + 'joked', + 'jokes', + 'jokey', + 'jokol', + 'joled', + 'joles', + 'jolls', + 'jolts', + 'jolty', + 'jomon', + 'jomos', + 'jones', + 'jongs', + 'jonty', + 'jooks', + 'joram', + 'jorum', + 'jotas', + 'jotty', + 'jotun', + 'joual', + 'jougs', + 'jouks', + 'joule', + 'jours', + 'jowar', + 'jowed', + 'jowls', + 'jowly', + 'joyed', + 'jubas', + 'jubes', + 'jucos', + 'judas', + 'judgy', + 'judos', + 'jugal', + 'jugum', + 'jujus', + 'juked', + 'jukes', + 'jukus', + 'julep', + 'jumar', + 'jumby', + 'jumps', + 'junco', + 'junks', + 'junky', + 'jupes', + 'jupon', + 'jural', + 'jurat', + 'jurel', + 'jures', + 'justs', + 'jutes', + 'jutty', + 'juves', + 'juvie', + 'kaama', + 'kabab', + 'kabar', + 'kabob', + 'kacha', + 'kacks', + 'kadai', + 'kades', + 'kadis', + 'kafir', + 'kagos', + 'kagus', + 'kahal', + 'kaiak', + 'kaids', + 'kaies', + 'kaifs', + 'kaika', + 'kaiks', + 'kails', + 'kaims', + 'kaing', + 'kains', + 'kakas', + 'kakis', + 'kalam', + 'kales', + 'kalif', + 'kalis', + 'kalpa', + 'kamas', + 'kames', + 'kamik', + 'kamis', + 'kamme', + 'kanae', + 'kanas', + 'kandy', + 'kaneh', + 'kanes', + 'kanga', + 'kangs', + 'kanji', + 'kants', + 'kanzu', + 'kaons', + 'kapas', + 'kaphs', + 'kapok', + 'kapow', + 'kapus', + 'kaput', + 'karas', + 'karat', + 'karks', + 'karns', + 'karoo', + 'karos', + 'karri', + 'karst', + 'karsy', + 'karts', + 'karzy', + 'kasha', + 'kasme', + 'katal', + 'katas', + 'katis', + 'katti', + 'kaugh', + 'kauri', + 'kauru', + 'kaury', + 'kaval', + 'kavas', + 'kawas', + 'kawau', + 'kawed', + 'kayle', + 'kayos', + 'kazis', + 'kazoo', + 'kbars', + 'kebar', + 'kebob', + 'kecks', + 'kedge', + 'kedgy', + 'keech', + 'keefs', + 'keeks', + 'keels', + 'keema', + 'keeno', + 'keens', + 'keeps', + 'keets', + 'keeve', + 'kefir', + 'kehua', + 'keirs', + 'kelep', + 'kelim', + 'kells', + 'kelly', + 'kelps', + 'kelpy', + 'kelts', + 'kelty', + 'kembo', + 'kembs', + 'kemps', + 'kempt', + 'kempy', + 'kenaf', + 'kench', + 'kendo', + 'kenos', + 'kente', + 'kents', + 'kepis', + 'kerbs', + 'kerel', + 'kerfs', + 'kerky', + 'kerma', + 'kerne', + 'kerns', + 'keros', + 'kerry', + 'kerve', + 'kesar', + 'kests', + 'ketas', + 'ketch', + 'ketes', + 'ketol', + 'kevel', + 'kevil', + 'kexes', + 'keyed', + 'keyer', + 'khadi', + 'khafs', + 'khans', + 'khaph', + 'khats', + 'khaya', + 'khazi', + 'kheda', + 'kheth', + 'khets', + 'khoja', + 'khors', + 'khoum', + 'khuds', + 'kiaat', + 'kiack', + 'kiang', + 'kibbe', + 'kibbi', + 'kibei', + 'kibes', + 'kibla', + 'kicks', + 'kicky', + 'kiddo', + 'kiddy', + 'kidel', + 'kidge', + 'kiefs', + 'kiers', + 'kieve', + 'kievs', + 'kight', + 'kikes', + 'kikoi', + 'kiley', + 'kilim', + 'kills', + 'kilns', + 'kilos', + 'kilps', + 'kilts', + 'kilty', + 'kimbo', + 'kinas', + 'kinda', + 'kinds', + 'kindy', + 'kines', + 'kings', + 'kinin', + 'kinks', + 'kinos', + 'kiore', + 'kipes', + 'kippa', + 'kipps', + 'kirby', + 'kirks', + 'kirns', + 'kirri', + 'kisan', + 'kissy', + 'kists', + 'kited', + 'kiter', + 'kites', + 'kithe', + 'kiths', + 'kitul', + 'kivas', + 'kiwis', + 'klang', + 'klaps', + 'klett', + 'klick', + 'klieg', + 'kliks', + 'klong', + 'kloof', + 'kluge', + 'klutz', + 'knags', + 'knaps', + 'knarl', + 'knars', + 'knaur', + 'knawe', + 'knees', + 'knell', + 'knish', + 'knits', + 'knive', + 'knobs', + 'knops', + 'knosp', + 'knots', + 'knout', + 'knowe', + 'knows', + 'knubs', + 'knurl', + 'knurr', + 'knurs', + 'knuts', + 'koans', + 'koaps', + 'koban', + 'kobos', + 'koels', + 'koffs', + 'kofta', + 'kogal', + 'kohas', + 'kohen', + 'kohls', + 'koine', + 'kojis', + 'kokam', + 'kokas', + 'koker', + 'kokra', + 'kokum', + 'kolas', + 'kolos', + 'kombu', + 'konbu', + 'kondo', + 'konks', + 'kooks', + 'kooky', + 'koori', + 'kopek', + 'kophs', + 'kopje', + 'koppa', + 'korai', + 'koras', + 'korat', + 'kores', + 'korma', + 'koros', + 'korun', + 'korus', + 'koses', + 'kotch', + 'kotos', + 'kotow', + 'koura', + 'kraal', + 'krabs', + 'kraft', + 'krais', + 'krait', + 'krang', + 'krans', + 'kranz', + 'kraut', + 'krays', + 'kreep', + 'kreng', + 'krewe', + 'krona', + 'krone', + 'kroon', + 'krubi', + 'krunk', + 'ksars', + 'kubie', + 'kudos', + 'kudus', + 'kudzu', + 'kufis', + 'kugel', + 'kuias', + 'kukri', + 'kukus', + 'kulak', + 'kulan', + 'kulas', + 'kulfi', + 'kumis', + 'kumys', + 'kuris', + 'kurre', + 'kurta', + 'kurus', + 'kusso', + 'kutas', + 'kutch', + 'kutis', + 'kutus', + 'kuzus', + 'kvass', + 'kvell', + 'kwela', + 'kyack', + 'kyaks', + 'kyang', + 'kyars', + 'kyats', + 'kybos', + 'kydst', + 'kyles', + 'kylie', + 'kylin', + 'kylix', + 'kyloe', + 'kynde', + 'kynds', + 'kypes', + 'kyrie', + 'kytes', + 'kythe', + 'laari', + 'labda', + 'labia', + 'labis', + 'labra', + 'laced', + 'lacer', + 'laces', + 'lacet', + 'lacey', + 'lacks', + 'laddy', + 'laded', + 'lader', + 'lades', + 'laers', + 'laevo', + 'lagan', + 'lahal', + 'lahar', + 'laich', + 'laics', + 'laids', + 'laigh', + 'laika', + 'laiks', + 'laird', + 'lairs', + 'lairy', + 'laith', + 'laity', + 'laked', + 'laker', + 'lakes', + 'lakhs', + 'lakin', + 'laksa', + 'laldy', + 'lalls', + 'lamas', + 'lambs', + 'lamby', + 'lamed', + 'lamer', + 'lames', + 'lamia', + 'lammy', + 'lamps', + 'lanai', + 'lanas', + 'lanch', + 'lande', + 'lands', + 'lanes', + 'lanks', + 'lants', + 'lapin', + 'lapis', + 'lapje', + 'larch', + 'lards', + 'lardy', + 'laree', + 'lares', + 'largo', + 'laris', + 'larks', + 'larky', + 'larns', + 'larnt', + 'larum', + 'lased', + 'laser', + 'lases', + 'lassi', + 'lassu', + 'lassy', + 'lasts', + 'latah', + 'lated', + 'laten', + 'latex', + 'lathi', + 'laths', + 'lathy', + 'latke', + 'latus', + 'lauan', + 'lauch', + 'lauds', + 'laufs', + 'laund', + 'laura', + 'laval', + 'lavas', + 'laved', + 'laver', + 'laves', + 'lavra', + 'lavvy', + 'lawed', + 'lawer', + 'lawin', + 'lawks', + 'lawns', + 'lawny', + 'laxed', + 'laxer', + 'laxes', + 'laxly', + 'layed', + 'layin', + 'layup', + 'lazar', + 'lazed', + 'lazes', + 'lazos', + 'lazzi', + 'lazzo', + 'leads', + 'leady', + 'leafs', + 'leaks', + 'leams', + 'leans', + 'leany', + 'leaps', + 'leare', + 'lears', + 'leary', + 'leats', + 'leavy', + 'leaze', + 'leben', + 'leccy', + 'ledes', + 'ledgy', + 'ledum', + 'leear', + 'leeks', + 'leeps', + 'leers', + 'leese', + 'leets', + 'leeze', + 'lefte', + 'lefts', + 'leger', + 'leges', + 'legge', + 'leggo', + 'legit', + 'lehrs', + 'lehua', + 'leirs', + 'leish', + 'leman', + 'lemed', + 'lemel', + 'lemes', + 'lemma', + 'lemme', + 'lends', + 'lenes', + 'lengs', + 'lenis', + 'lenos', + 'lense', + 'lenti', + 'lento', + 'leone', + 'lepid', + 'lepra', + 'lepta', + 'lered', + 'leres', + 'lerps', + 'lesbo', + 'leses', + 'lests', + 'letch', + 'lethe', + 'letup', + 'leuch', + 'leuco', + 'leuds', + 'leugh', + 'levas', + 'levee', + 'leves', + 'levin', + 'levis', + 'lewis', + 'lexes', + 'lexis', + 'lezes', + 'lezza', + 'lezzy', + 'liana', + 'liane', + 'liang', + 'liard', + 'liars', + 'liart', + 'liber', + 'libra', + 'libri', + 'lichi', + 'licht', + 'licit', + 'licks', + 'lidar', + 'lidos', + 'liefs', + 'liens', + 'liers', + 'lieus', + 'lieve', + 'lifer', + 'lifes', + 'lifts', + 'ligan', + 'liger', + 'ligge', + 'ligne', + 'liked', + 'liker', + 'likes', + 'likin', + 'lills', + 'lilos', + 'lilts', + 'liman', + 'limas', + 'limax', + 'limba', + 'limbi', + 'limbs', + 'limby', + 'limed', + 'limen', + 'limes', + 'limey', + 'limma', + 'limns', + 'limos', + 'limpa', + 'limps', + 'linac', + 'linch', + 'linds', + 'lindy', + 'lined', + 'lines', + 'liney', + 'linga', + 'lings', + 'lingy', + 'linin', + 'links', + 'linky', + 'linns', + 'linny', + 'linos', + 'lints', + 'linty', + 'linum', + 'linux', + 'lions', + 'lipas', + 'lipes', + 'lipin', + 'lipos', + 'lippy', + 'liras', + 'lirks', + 'lirot', + 'lisks', + 'lisle', + 'lisps', + 'lists', + 'litai', + 'litas', + 'lited', + 'liter', + 'lites', + 'litho', + 'liths', + 'litre', + 'lived', + 'liven', + 'lives', + 'livor', + 'livre', + 'llano', + 'loach', + 'loads', + 'loafs', + 'loams', + 'loans', + 'loast', + 'loave', + 'lobar', + 'lobed', + 'lobes', + 'lobos', + 'lobus', + 'loche', + 'lochs', + 'locie', + 'locis', + 'locks', + 'locos', + 'locum', + 'loden', + 'lodes', + 'loess', + 'lofts', + 'logan', + 'loges', + 'loggy', + 'logia', + 'logie', + 'logoi', + 'logon', + 'logos', + 'lohan', + 'loids', + 'loins', + 'loipe', + 'loirs', + 'lokes', + 'lolls', + 'lolly', + 'lolog', + 'lomas', + 'lomed', + 'lomes', + 'loner', + 'longa', + 'longe', + 'longs', + 'looby', + 'looed', + 'looey', + 'loofa', + 'loofs', + 'looie', + 'looks', + 'looky', + 'looms', + 'loons', + 'loony', + 'loops', + 'loord', + 'loots', + 'loped', + 'loper', + 'lopes', + 'loppy', + 'loral', + 'loran', + 'lords', + 'lordy', + 'lorel', + 'lores', + 'loric', + 'loris', + 'losed', + 'losel', + 'losen', + 'loses', + 'lossy', + 'lotah', + 'lotas', + 'lotes', + 'lotic', + 'lotos', + 'lotsa', + 'lotta', + 'lotte', + 'lotto', + 'lotus', + 'loued', + 'lough', + 'louie', + 'louis', + 'louma', + 'lound', + 'louns', + 'loupe', + 'loups', + 'loure', + 'lours', + 'loury', + 'louts', + 'lovat', + 'loved', + 'loves', + 'lovey', + 'lovie', + 'lowan', + 'lowed', + 'lowes', + 'lownd', + 'lowne', + 'lowns', + 'lowps', + 'lowry', + 'lowse', + 'lowts', + 'loxed', + 'loxes', + 'lozen', + 'luach', + 'luaus', + 'lubed', + 'lubes', + 'lubra', + 'luces', + 'lucks', + 'lucre', + 'ludes', + 'ludic', + 'ludos', + 'luffa', + 'luffs', + 'luged', + 'luger', + 'luges', + 'lulls', + 'lulus', + 'lumas', + 'lumbi', + 'lumme', + 'lummy', + 'lumps', + 'lunas', + 'lunes', + 'lunet', + 'lungi', + 'lungs', + 'lunks', + 'lunts', + 'lupin', + 'lured', + 'lurer', + 'lures', + 'lurex', + 'lurgi', + 'lurgy', + 'lurks', + 'lurry', + 'lurve', + 'luser', + 'lushy', + 'lusks', + 'lusts', + 'lusus', + 'lutea', + 'luted', + 'luter', + 'lutes', + 'luvvy', + 'luxed', + 'luxer', + 'luxes', + 'lweis', + 'lyams', + 'lyard', + 'lyart', + 'lyase', + 'lycea', + 'lycee', + 'lycra', + 'lymes', + 'lynes', + 'lyres', + 'lysed', + 'lyses', + 'lysin', + 'lysis', + 'lysol', + 'lyssa', + 'lyted', + 'lytes', + 'lythe', + 'lytic', + 'lytta', + 'maaed', + 'maare', + 'maars', + 'mabes', + 'macas', + 'maced', + 'macer', + 'maces', + 'mache', + 'machi', + 'machs', + 'macks', + 'macle', + 'macon', + 'madge', + 'madid', + 'madre', + 'maerl', + 'mafic', + 'mages', + 'maggs', + 'magot', + 'magus', + 'mahoe', + 'mahua', + 'mahwa', + 'maids', + 'maiko', + 'maiks', + 'maile', + 'maill', + 'mails', + 'maims', + 'mains', + 'maire', + 'mairs', + 'maise', + 'maist', + 'makar', + 'makes', + 'makis', + 'makos', + 'malam', + 'malar', + 'malas', + 'malax', + 'males', + 'malic', + 'malik', + 'malis', + 'malls', + 'malms', + 'malmy', + 'malts', + 'malty', + 'malus', + 'malva', + 'malwa', + 'mamas', + 'mamba', + 'mamee', + 'mamey', + 'mamie', + 'manas', + 'manat', + 'mandi', + 'maneb', + 'maned', + 'maneh', + 'manes', + 'manet', + 'mangs', + 'manis', + 'manky', + 'manna', + 'manos', + 'manse', + 'manta', + 'manto', + 'manty', + 'manul', + 'manus', + 'mapau', + 'maqui', + 'marae', + 'marah', + 'maras', + 'marcs', + 'mardy', + 'mares', + 'marge', + 'margs', + 'maria', + 'marid', + 'marka', + 'marks', + 'marle', + 'marls', + 'marly', + 'marms', + 'maron', + 'maror', + 'marra', + 'marri', + 'marse', + 'marts', + 'marvy', + 'masas', + 'mased', + 'maser', + 'mases', + 'mashy', + 'masks', + 'massa', + 'massy', + 'masts', + 'masty', + 'masus', + 'matai', + 'mated', + 'mater', + 'mates', + 'maths', + 'matin', + 'matlo', + 'matte', + 'matts', + 'matza', + 'matzo', + 'mauby', + 'mauds', + 'mauls', + 'maund', + 'mauri', + 'mausy', + 'mauts', + 'mauzy', + 'maven', + 'mavie', + 'mavin', + 'mavis', + 'mawed', + 'mawks', + 'mawky', + 'mawns', + 'mawrs', + 'maxed', + 'maxes', + 'maxis', + 'mayan', + 'mayas', + 'mayed', + 'mayos', + 'mayst', + 'mazed', + 'mazer', + 'mazes', + 'mazey', + 'mazut', + 'mbira', + 'meads', + 'meals', + 'meane', + 'means', + 'meany', + 'meare', + 'mease', + 'meath', + 'meats', + 'mebos', + 'mechs', + 'mecks', + 'medii', + 'medle', + 'meeds', + 'meers', + 'meets', + 'meffs', + 'meins', + 'meint', + 'meiny', + 'meith', + 'mekka', + 'melas', + 'melba', + 'melds', + 'melic', + 'melik', + 'mells', + 'melts', + 'melty', + 'memes', + 'memos', + 'menad', + 'mends', + 'mened', + 'menes', + 'menge', + 'mengs', + 'mensa', + 'mense', + 'mensh', + 'menta', + 'mento', + 'menus', + 'meous', + 'meows', + 'merch', + 'mercs', + 'merde', + 'mered', + 'merel', + 'merer', + 'meres', + 'meril', + 'meris', + 'merks', + 'merle', + 'merls', + 'merse', + 'mesal', + 'mesas', + 'mesel', + 'meses', + 'meshy', + 'mesic', + 'mesne', + 'meson', + 'messy', + 'mesto', + 'meted', + 'metes', + 'metho', + 'meths', + 'metic', + 'metif', + 'metis', + 'metol', + 'metre', + 'meuse', + 'meved', + 'meves', + 'mewed', + 'mewls', + 'meynt', + 'mezes', + 'mezze', + 'mezzo', + 'mhorr', + 'miaou', + 'miaow', + 'miasm', + 'miaul', + 'micas', + 'miche', + 'micht', + 'micks', + 'micky', + 'micos', + 'micra', + 'middy', + 'midgy', + 'midis', + 'miens', + 'mieve', + 'miffs', + 'miffy', + 'mifty', + 'miggs', + 'mihas', + 'mihis', + 'miked', + 'mikes', + 'mikra', + 'mikva', + 'milch', + 'milds', + 'miler', + 'miles', + 'milfs', + 'milia', + 'milko', + 'milks', + 'mille', + 'mills', + 'milor', + 'milos', + 'milpa', + 'milts', + 'milty', + 'miltz', + 'mimed', + 'mimeo', + 'mimer', + 'mimes', + 'mimsy', + 'minae', + 'minar', + 'minas', + 'mincy', + 'minds', + 'mined', + 'mines', + 'minge', + 'mings', + 'mingy', + 'minis', + 'minke', + 'minks', + 'minny', + 'minos', + 'mints', + 'mired', + 'mires', + 'mirex', + 'mirid', + 'mirin', + 'mirks', + 'mirky', + 'mirly', + 'miros', + 'mirvs', + 'mirza', + 'misch', + 'misdo', + 'mises', + 'misgo', + 'misos', + 'missa', + 'mists', + 'misty', + 'mitch', + 'miter', + 'mites', + 'mitis', + 'mitre', + 'mitts', + 'mixed', + 'mixen', + 'mixer', + 'mixes', + 'mixte', + 'mixup', + 'mizen', + 'mizzy', + 'mneme', + 'moans', + 'moats', + 'mobby', + 'mobes', + 'mobey', + 'mobie', + 'moble', + 'mochi', + 'mochs', + 'mochy', + 'mocks', + 'moder', + 'modes', + 'modge', + 'modii', + 'modus', + 'moers', + 'mofos', + 'moggy', + 'mohel', + 'mohos', + 'mohrs', + 'mohua', + 'mohur', + 'moile', + 'moils', + 'moira', + 'moire', + 'moits', + 'mojos', + 'mokes', + 'mokis', + 'mokos', + 'molal', + 'molas', + 'molds', + 'moled', + 'moles', + 'molla', + 'molls', + 'molly', + 'molto', + 'molts', + 'molys', + 'momes', + 'momma', + 'mommy', + 'momus', + 'monad', + 'monal', + 'monas', + 'monde', + 'mondo', + 'moner', + 'mongo', + 'mongs', + 'monic', + 'monie', + 'monks', + 'monos', + 'monte', + 'monty', + 'moobs', + 'mooch', + 'moods', + 'mooed', + 'mooks', + 'moola', + 'mooli', + 'mools', + 'mooly', + 'moong', + 'moons', + 'moony', + 'moops', + 'moors', + 'moory', + 'moots', + 'moove', + 'moped', + 'moper', + 'mopes', + 'mopey', + 'moppy', + 'mopsy', + 'mopus', + 'morae', + 'moras', + 'morat', + 'moray', + 'morel', + 'mores', + 'moria', + 'morne', + 'morns', + 'morra', + 'morro', + 'morse', + 'morts', + 'mosed', + 'moses', + 'mosey', + 'mosks', + 'mosso', + 'moste', + 'mosts', + 'moted', + 'moten', + 'motes', + 'motet', + 'motey', + 'moths', + 'mothy', + 'motis', + 'motte', + 'motts', + 'motty', + 'motus', + 'motza', + 'mouch', + 'moues', + 'mould', + 'mouls', + 'moups', + 'moust', + 'mousy', + 'moved', + 'moves', + 'mowas', + 'mowed', + 'mowra', + 'moxas', + 'moxie', + 'moyas', + 'moyle', + 'moyls', + 'mozed', + 'mozes', + 'mozos', + 'mpret', + 'mucho', + 'mucic', + 'mucid', + 'mucin', + 'mucks', + 'mucor', + 'mucro', + 'mudge', + 'mudir', + 'mudra', + 'muffs', + 'mufti', + 'mugga', + 'muggs', + 'muggy', + 'muhly', + 'muids', + 'muils', + 'muirs', + 'muist', + 'mujik', + 'mulct', + 'muled', + 'mules', + 'muley', + 'mulga', + 'mulie', + 'mulla', + 'mulls', + 'mulse', + 'mulsh', + 'mumms', + 'mumps', + 'mumsy', + 'mumus', + 'munga', + 'munge', + 'mungo', + 'mungs', + 'munis', + 'munts', + 'muntu', + 'muons', + 'muras', + 'mured', + 'mures', + 'murex', + 'murid', + 'murks', + 'murls', + 'murly', + 'murra', + 'murre', + 'murri', + 'murrs', + 'murry', + 'murti', + 'murva', + 'musar', + 'musca', + 'mused', + 'muser', + 'muses', + 'muset', + 'musha', + 'musit', + 'musks', + 'musos', + 'musse', + 'mussy', + 'musth', + 'musts', + 'mutch', + 'muted', + 'muter', + 'mutes', + 'mutha', + 'mutis', + 'muton', + 'mutts', + 'muxed', + 'muxes', + 'muzak', + 'muzzy', + 'mvule', + 'myall', + 'mylar', + 'mynah', + 'mynas', + 'myoid', + 'myoma', + 'myope', + 'myops', + 'myopy', + 'mysid', + 'mythi', + 'myths', + 'mythy', + 'myxos', + 'mzees', + 'naams', + 'naans', + 'nabes', + 'nabis', + 'nabks', + 'nabla', + 'nabob', + 'nache', + 'nacho', + 'nacre', + 'nadas', + 'naeve', + 'naevi', + 'naffs', + 'nagas', + 'naggy', + 'nagor', + 'nahal', + 'naiad', + 'naifs', + 'naiks', + 'nails', + 'naira', + 'nairu', + 'naked', + 'naker', + 'nakfa', + 'nalas', + 'naled', + 'nalla', + 'named', + 'namer', + 'names', + 'namma', + 'namus', + 'nanas', + 'nance', + 'nancy', + 'nandu', + 'nanna', + 'nanos', + 'nanua', + 'napas', + 'naped', + 'napes', + 'napoo', + 'nappa', + 'nappe', + 'nappy', + 'naras', + 'narco', + 'narcs', + 'nards', + 'nares', + 'naric', + 'naris', + 'narks', + 'narky', + 'narre', + 'nashi', + 'natch', + 'nates', + 'natis', + 'natty', + 'nauch', + 'naunt', + 'navar', + 'naves', + 'navew', + 'navvy', + 'nawab', + 'nazes', + 'nazir', + 'nazis', + 'nduja', + 'neafe', + 'neals', + 'neaps', + 'nears', + 'neath', + 'neats', + 'nebek', + 'nebel', + 'necks', + 'neddy', + 'needs', + 'neeld', + 'neele', + 'neemb', + 'neems', + 'neeps', + 'neese', + 'neeze', + 'negro', + 'negus', + 'neifs', + 'neist', + 'neive', + 'nelis', + 'nelly', + 'nemas', + 'nemns', + 'nempt', + 'nenes', + 'neons', + 'neper', + 'nepit', + 'neral', + 'nerds', + 'nerka', + 'nerks', + 'nerol', + 'nerts', + 'nertz', + 'nervy', + 'nests', + 'netes', + 'netop', + 'netts', + 'netty', + 'neuks', + 'neume', + 'neums', + 'nevel', + 'neves', + 'nevus', + 'newbs', + 'newed', + 'newel', + 'newie', + 'newsy', + 'newts', + 'nexts', + 'nexus', + 'ngaio', + 'ngana', + 'ngati', + 'ngoma', + 'ngwee', + 'nicad', + 'nicht', + 'nicks', + 'nicol', + 'nidal', + 'nided', + 'nides', + 'nidor', + 'nidus', + 'niefs', + 'nieve', + 'nifes', + 'niffs', + 'niffy', + 'nifty', + 'niger', + 'nighs', + 'nihil', + 'nikab', + 'nikah', + 'nikau', + 'nills', + 'nimbi', + 'nimbs', + 'nimps', + 'niner', + 'nines', + 'ninon', + 'nipas', + 'nippy', + 'niqab', + 'nirls', + 'nirly', + 'nisei', + 'nisse', + 'nisus', + 'niter', + 'nites', + 'nitid', + 'niton', + 'nitre', + 'nitro', + 'nitry', + 'nitty', + 'nival', + 'nixed', + 'nixer', + 'nixes', + 'nixie', + 'nizam', + 'nkosi', + 'noahs', + 'nobby', + 'nocks', + 'nodal', + 'noddy', + 'nodes', + 'nodus', + 'noels', + 'noggs', + 'nohow', + 'noils', + 'noily', + 'noint', + 'noirs', + 'noles', + 'nolls', + 'nolos', + 'nomas', + 'nomen', + 'nomes', + 'nomic', + 'nomoi', + 'nomos', + 'nonas', + 'nonce', + 'nones', + 'nonet', + 'nongs', + 'nonis', + 'nonny', + 'nonyl', + 'noobs', + 'nooit', + 'nooks', + 'nooky', + 'noons', + 'noops', + 'nopal', + 'noria', + 'noris', + 'norks', + 'norma', + 'norms', + 'nosed', + 'noser', + 'noses', + 'notal', + 'noted', + 'noter', + 'notes', + 'notum', + 'nould', + 'noule', + 'nouls', + 'nouns', + 'nouny', + 'noups', + 'novae', + 'novas', + 'novum', + 'noway', + 'nowed', + 'nowls', + 'nowts', + 'nowty', + 'noxal', + 'noxes', + 'noyau', + 'noyed', + 'noyes', + 'nubby', + 'nubia', + 'nucha', + 'nuddy', + 'nuder', + 'nudes', + 'nudie', + 'nudzh', + 'nuffs', + 'nugae', + 'nuked', + 'nukes', + 'nulla', + 'nulls', + 'numbs', + 'numen', + 'nummy', + 'nunny', + 'nurds', + 'nurdy', + 'nurls', + 'nurrs', + 'nutso', + 'nutsy', + 'nyaff', + 'nyala', + 'nying', + 'nyssa', + 'oaked', + 'oaker', + 'oakum', + 'oared', + 'oases', + 'oasis', + 'oasts', + 'oaten', + 'oater', + 'oaths', + 'oaves', + 'obang', + 'obeah', + 'obeli', + 'obeys', + 'obias', + 'obied', + 'obiit', + 'obits', + 'objet', + 'oboes', + 'obole', + 'oboli', + 'obols', + 'occam', + 'ocher', + 'oches', + 'ochre', + 'ochry', + 'ocker', + 'ocrea', + 'octad', + 'octan', + 'octas', + 'octyl', + 'oculi', + 'odahs', + 'odals', + 'odeon', + 'odeum', + 'odism', + 'odist', + 'odium', + 'odors', + 'odour', + 'odyle', + 'odyls', + 'ofays', + 'offed', + 'offie', + 'oflag', + 'ofter', + 'ogams', + 'ogeed', + 'ogees', + 'oggin', + 'ogham', + 'ogive', + 'ogled', + 'ogler', + 'ogles', + 'ogmic', + 'ogres', + 'ohias', + 'ohing', + 'ohmic', + 'ohone', + 'oidia', + 'oiled', + 'oiler', + 'oinks', + 'oints', + 'ojime', + 'okapi', + 'okays', + 'okehs', + 'okras', + 'oktas', + 'oldie', + 'oleic', + 'olein', + 'olent', + 'oleos', + 'oleum', + 'olios', + 'ollas', + 'ollav', + 'oller', + 'ollie', + 'ology', + 'olpae', + 'olpes', + 'omasa', + 'omber', + 'ombus', + 'omens', + 'omers', + 'omits', + 'omlah', + 'omovs', + 'omrah', + 'oncer', + 'onces', + 'oncet', + 'oncus', + 'onely', + 'oners', + 'onery', + 'onium', + 'onkus', + 'onlay', + 'onned', + 'ontic', + 'oobit', + 'oohed', + 'oomph', + 'oonts', + 'ooped', + 'oorie', + 'ooses', + 'ootid', + 'oozed', + 'oozes', + 'opahs', + 'opals', + 'opens', + 'opepe', + 'oping', + 'oppos', + 'opsin', + 'opted', + 'opter', + 'orach', + 'oracy', + 'orals', + 'orang', + 'orant', + 'orate', + 'orbed', + 'orcas', + 'orcin', + 'ordos', + 'oread', + 'orfes', + 'orgia', + 'orgic', + 'orgue', + 'oribi', + 'oriel', + 'orixa', + 'orles', + 'orlon', + 'orlop', + 'ormer', + 'ornis', + 'orpin', + 'orris', + 'ortho', + 'orval', + 'orzos', + 'oscar', + 'oshac', + 'osier', + 'osmic', + 'osmol', + 'ossia', + 'ostia', + 'otaku', + 'otary', + 'ottar', + 'ottos', + 'oubit', + 'oucht', + 'ouens', + 'ouija', + 'oulks', + 'oumas', + 'oundy', + 'oupas', + 'ouped', + 'ouphe', + 'ouphs', + 'ourie', + 'ousel', + 'ousts', + 'outby', + 'outed', + 'outre', + 'outro', + 'outta', + 'ouzel', + 'ouzos', + 'ovals', + 'ovels', + 'ovens', + 'overs', + 'ovist', + 'ovoli', + 'ovolo', + 'ovule', + 'owche', + 'owies', + 'owled', + 'owler', + 'owlet', + 'owned', + 'owres', + 'owrie', + 'owsen', + 'oxbow', + 'oxers', + 'oxeye', + 'oxids', + 'oxies', + 'oxime', + 'oxims', + 'oxlip', + 'oxter', + 'oyers', + 'ozeki', + 'ozzie', + 'paals', + 'paans', + 'pacas', + 'paced', + 'pacer', + 'paces', + 'pacey', + 'pacha', + 'packs', + 'pacos', + 'pacta', + 'pacts', + 'padis', + 'padle', + 'padma', + 'padre', + 'padri', + 'paean', + 'paedo', + 'paeon', + 'paged', + 'pager', + 'pages', + 'pagle', + 'pagod', + 'pagri', + 'paiks', + 'pails', + 'pains', + 'paire', + 'pairs', + 'paisa', + 'paise', + 'pakka', + 'palas', + 'palay', + 'palea', + 'paled', + 'pales', + 'palet', + 'palis', + 'palki', + 'palla', + 'palls', + 'pally', + 'palms', + 'palmy', + 'palpi', + 'palps', + 'palsa', + 'pampa', + 'panax', + 'pance', + 'panda', + 'pands', + 'pandy', + 'paned', + 'panes', + 'panga', + 'pangs', + 'panim', + 'panko', + 'panne', + 'panni', + 'panto', + 'pants', + 'panty', + 'paoli', + 'paolo', + 'papas', + 'papaw', + 'papes', + 'pappi', + 'pappy', + 'parae', + 'paras', + 'parch', + 'pardi', + 'pards', + 'pardy', + 'pared', + 'paren', + 'pareo', + 'pares', + 'pareu', + 'parev', + 'parge', + 'pargo', + 'paris', + 'parki', + 'parks', + 'parky', + 'parle', + 'parly', + 'parma', + 'parol', + 'parps', + 'parra', + 'parrs', + 'parti', + 'parts', + 'parve', + 'parvo', + 'paseo', + 'pases', + 'pasha', + 'pashm', + 'paska', + 'paspy', + 'passe', + 'pasts', + 'pated', + 'paten', + 'pater', + 'pates', + 'paths', + 'patin', + 'patka', + 'patly', + 'patte', + 'patus', + 'pauas', + 'pauls', + 'pavan', + 'paved', + 'paven', + 'paver', + 'paves', + 'pavid', + 'pavin', + 'pavis', + 'pawas', + 'pawaw', + 'pawed', + 'pawer', + 'pawks', + 'pawky', + 'pawls', + 'pawns', + 'paxes', + 'payed', + 'payor', + 'paysd', + 'peage', + 'peags', + 'peaks', + 'peaky', + 'peals', + 'peans', + 'peare', + 'pears', + 'peart', + 'pease', + 'peats', + 'peaty', + 'peavy', + 'peaze', + 'pebas', + 'pechs', + 'pecke', + 'pecks', + 'pecky', + 'pedes', + 'pedis', + 'pedro', + 'peece', + 'peeks', + 'peels', + 'peens', + 'peeoy', + 'peepe', + 'peeps', + 'peers', + 'peery', + 'peeve', + 'peggy', + 'peghs', + 'peins', + 'peise', + 'peize', + 'pekan', + 'pekes', + 'pekin', + 'pekoe', + 'pelas', + 'pelau', + 'peles', + 'pelfs', + 'pells', + 'pelma', + 'pelon', + 'pelta', + 'pelts', + 'pends', + 'pendu', + 'pened', + 'penes', + 'pengo', + 'penie', + 'penis', + 'penks', + 'penna', + 'penni', + 'pents', + 'peons', + 'peony', + 'pepla', + 'pepos', + 'peppy', + 'pepsi', + 'perai', + 'perce', + 'percs', + 'perdu', + 'perdy', + 'perea', + 'peres', + 'peris', + 'perks', + 'perms', + 'perns', + 'perog', + 'perps', + 'perry', + 'perse', + 'perst', + 'perts', + 'perve', + 'pervo', + 'pervs', + 'pervy', + 'pesos', + 'pests', + 'pesty', + 'petar', + 'peter', + 'petit', + 'petre', + 'petri', + 'petti', + 'petto', + 'pewee', + 'pewit', + 'peyse', + 'phage', + 'phang', + 'phare', + 'pharm', + 'pheer', + 'phene', + 'pheon', + 'phese', + 'phial', + 'phish', + 'phizz', + 'phlox', + 'phoca', + 'phono', + 'phons', + 'phots', + 'phpht', + 'phuts', + 'phyla', + 'phyle', + 'piani', + 'pians', + 'pibal', + 'pical', + 'picas', + 'piccy', + 'picks', + 'picot', + 'picra', + 'picul', + 'piend', + 'piers', + 'piert', + 'pieta', + 'piets', + 'piezo', + 'pight', + 'pigmy', + 'piing', + 'pikas', + 'pikau', + 'piked', + 'piker', + 'pikes', + 'pikey', + 'pikis', + 'pikul', + 'pilae', + 'pilaf', + 'pilao', + 'pilar', + 'pilau', + 'pilaw', + 'pilch', + 'pilea', + 'piled', + 'pilei', + 'piler', + 'piles', + 'pilis', + 'pills', + 'pilow', + 'pilum', + 'pilus', + 'pimas', + 'pimps', + 'pinas', + 'pined', + 'pines', + 'pingo', + 'pings', + 'pinko', + 'pinks', + 'pinna', + 'pinny', + 'pinon', + 'pinot', + 'pinta', + 'pints', + 'pinup', + 'pions', + 'piony', + 'pious', + 'pioye', + 'pioys', + 'pipal', + 'pipas', + 'piped', + 'pipes', + 'pipet', + 'pipis', + 'pipit', + 'pippy', + 'pipul', + 'pirai', + 'pirls', + 'pirns', + 'pirog', + 'pisco', + 'pises', + 'pisky', + 'pisos', + 'pissy', + 'piste', + 'pitas', + 'piths', + 'piton', + 'pitot', + 'pitta', + 'piums', + 'pixes', + 'pized', + 'pizes', + 'plaas', + 'plack', + 'plage', + 'plans', + 'plaps', + 'plash', + 'plasm', + 'plast', + 'plats', + 'platt', + 'platy', + 'playa', + 'plays', + 'pleas', + 'plebe', + 'plebs', + 'plena', + 'pleon', + 'plesh', + 'plews', + 'plica', + 'plies', + 'plims', + 'pling', + 'plink', + 'ploat', + 'plods', + 'plong', + 'plonk', + 'plook', + 'plops', + 'plots', + 'plotz', + 'plouk', + 'plows', + 'ploye', + 'ploys', + 'plues', + 'pluff', + 'plugs', + 'plums', + 'plumy', + 'pluot', + 'pluto', + 'plyer', + 'poach', + 'poaka', + 'poake', + 'poboy', + 'pocks', + 'pocky', + 'podal', + 'poddy', + 'podex', + 'podge', + 'podgy', + 'podia', + 'poems', + 'poeps', + 'poets', + 'pogey', + 'pogge', + 'pogos', + 'pohed', + 'poilu', + 'poind', + 'pokal', + 'poked', + 'pokes', + 'pokey', + 'pokie', + 'poled', + 'poler', + 'poles', + 'poley', + 'polio', + 'polis', + 'polje', + 'polks', + 'polls', + 'polly', + 'polos', + 'polts', + 'polys', + 'pombe', + 'pomes', + 'pommy', + 'pomos', + 'pomps', + 'ponce', + 'poncy', + 'ponds', + 'pones', + 'poney', + 'ponga', + 'pongo', + 'pongs', + 'pongy', + 'ponks', + 'ponts', + 'ponty', + 'ponzu', + 'poods', + 'pooed', + 'poofs', + 'poofy', + 'poohs', + 'pooja', + 'pooka', + 'pooks', + 'pools', + 'poons', + 'poops', + 'poopy', + 'poori', + 'poort', + 'poots', + 'poove', + 'poovy', + 'popes', + 'poppa', + 'popsy', + 'porae', + 'poral', + 'pored', + 'porer', + 'pores', + 'porge', + 'porgy', + 'porin', + 'porks', + 'porky', + 'porno', + 'porns', + 'porny', + 'porta', + 'ports', + 'porty', + 'posed', + 'poses', + 'posey', + 'posho', + 'posts', + 'potae', + 'potch', + 'poted', + 'potes', + 'potin', + 'potoo', + 'potsy', + 'potto', + 'potts', + 'potty', + 'pouff', + 'poufs', + 'pouke', + 'pouks', + 'poule', + 'poulp', + 'poult', + 'poupe', + 'poupt', + 'pours', + 'pouts', + 'powan', + 'powin', + 'pownd', + 'powns', + 'powny', + 'powre', + 'poxed', + 'poxes', + 'poynt', + 'poyou', + 'poyse', + 'pozzy', + 'praam', + 'prads', + 'prahu', + 'prams', + 'prana', + 'prang', + 'praos', + 'prase', + 'prate', + 'prats', + 'pratt', + 'praty', + 'praus', + 'prays', + 'predy', + 'preed', + 'prees', + 'preif', + 'prems', + 'premy', + 'prent', + 'preon', + 'preop', + 'preps', + 'presa', + 'prese', + 'prest', + 'preve', + 'prexy', + 'preys', + 'prial', + 'pricy', + 'prief', + 'prier', + 'pries', + 'prigs', + 'prill', + 'prima', + 'primi', + 'primp', + 'prims', + 'primy', + 'prink', + 'prion', + 'prise', + 'priss', + 'proas', + 'probs', + 'prods', + 'proem', + 'profs', + 'progs', + 'proin', + 'proke', + 'prole', + 'proll', + 'promo', + 'proms', + 'pronk', + 'props', + 'prore', + 'proso', + 'pross', + 'prost', + 'prosy', + 'proto', + 'proul', + 'prows', + 'proyn', + 'prunt', + 'pruta', + 'pryer', + 'pryse', + 'pseud', + 'pshaw', + 'psion', + 'psoae', + 'psoai', + 'psoas', + 'psora', + 'psych', + 'psyop', + 'pubco', + 'pubes', + 'pubis', + 'pucan', + 'pucer', + 'puces', + 'pucka', + 'pucks', + 'puddy', + 'pudge', + 'pudic', + 'pudor', + 'pudsy', + 'pudus', + 'puers', + 'puffa', + 'puffs', + 'puggy', + 'pugil', + 'puhas', + 'pujah', + 'pujas', + 'pukas', + 'puked', + 'puker', + 'pukes', + 'pukey', + 'pukka', + 'pukus', + 'pulao', + 'pulas', + 'puled', + 'puler', + 'pules', + 'pulik', + 'pulis', + 'pulka', + 'pulks', + 'pulli', + 'pulls', + 'pully', + 'pulmo', + 'pulps', + 'pulus', + 'pumas', + 'pumie', + 'pumps', + 'punas', + 'punce', + 'punga', + 'pungs', + 'punji', + 'punka', + 'punks', + 'punky', + 'punny', + 'punto', + 'punts', + 'punty', + 'pupae', + 'pupas', + 'pupus', + 'purda', + 'pured', + 'pures', + 'purin', + 'puris', + 'purls', + 'purpy', + 'purrs', + 'pursy', + 'purty', + 'puses', + 'pusle', + 'pussy', + 'putid', + 'puton', + 'putti', + 'putto', + 'putts', + 'puzel', + 'pwned', + 'pyats', + 'pyets', + 'pygal', + 'pyins', + 'pylon', + 'pyned', + 'pynes', + 'pyoid', + 'pyots', + 'pyral', + 'pyran', + 'pyres', + 'pyrex', + 'pyric', + 'pyros', + 'pyxed', + 'pyxes', + 'pyxie', + 'pyxis', + 'pzazz', + 'qadis', + 'qaids', + 'qajaq', + 'qanat', + 'qapik', + 'qibla', + 'qophs', + 'qorma', + 'quads', + 'quaff', + 'quags', + 'quair', + 'quais', + 'quaky', + 'quale', + 'quant', + 'quare', + 'quass', + 'quate', + 'quats', + 'quayd', + 'quays', + 'qubit', + 'quean', + 'queme', + 'quena', + 'quern', + 'queyn', + 'queys', + 'quich', + 'quids', + 'quiff', + 'quims', + 'quina', + 'quine', + 'quino', + 'quins', + 'quint', + 'quipo', + 'quips', + 'quipu', + 'quire', + 'quirt', + 'quist', + 'quits', + 'quoad', + 'quods', + 'quoif', + 'quoin', + 'quoit', + 'quoll', + 'quonk', + 'quops', + 'qursh', + 'quyte', + 'rabat', + 'rabic', + 'rabis', + 'raced', + 'races', + 'rache', + 'racks', + 'racon', + 'radge', + 'radix', + 'radon', + 'raffs', + 'rafts', + 'ragas', + 'ragde', + 'raged', + 'ragee', + 'rager', + 'rages', + 'ragga', + 'raggs', + 'raggy', + 'ragis', + 'ragus', + 'rahed', + 'rahui', + 'raias', + 'raids', + 'raiks', + 'raile', + 'rails', + 'raine', + 'rains', + 'raird', + 'raita', + 'raits', + 'rajas', + 'rajes', + 'raked', + 'rakee', + 'raker', + 'rakes', + 'rakia', + 'rakis', + 'rakus', + 'rales', + 'ramal', + 'ramee', + 'ramet', + 'ramie', + 'ramin', + 'ramis', + 'rammy', + 'ramps', + 'ramus', + 'ranas', + 'rance', + 'rands', + 'ranee', + 'ranga', + 'rangi', + 'rangs', + 'rangy', + 'ranid', + 'ranis', + 'ranke', + 'ranks', + 'rants', + 'raped', + 'raper', + 'rapes', + 'raphe', + 'rappe', + 'rared', + 'raree', + 'rares', + 'rarks', + 'rased', + 'raser', + 'rases', + 'rasps', + 'rasse', + 'rasta', + 'ratal', + 'ratan', + 'ratas', + 'ratch', + 'rated', + 'ratel', + 'rater', + 'rates', + 'ratha', + 'rathe', + 'raths', + 'ratoo', + 'ratos', + 'ratus', + 'rauns', + 'raupo', + 'raved', + 'ravel', + 'raver', + 'raves', + 'ravey', + 'ravin', + 'rawer', + 'rawin', + 'rawly', + 'rawns', + 'raxed', + 'raxes', + 'rayah', + 'rayas', + 'rayed', + 'rayle', + 'rayne', + 'razed', + 'razee', + 'razer', + 'razes', + 'razoo', + 'readd', + 'reads', + 'reais', + 'reaks', + 'realo', + 'reals', + 'reame', + 'reams', + 'reamy', + 'reans', + 'reaps', + 'rears', + 'reast', + 'reata', + 'reate', + 'reave', + 'rebbe', + 'rebec', + 'rebid', + 'rebit', + 'rebop', + 'rebuy', + 'recal', + 'recce', + 'recco', + 'reccy', + 'recit', + 'recks', + 'recon', + 'recta', + 'recti', + 'recto', + 'redan', + 'redds', + 'reddy', + 'reded', + 'redes', + 'redia', + 'redid', + 'redip', + 'redly', + 'redon', + 'redos', + 'redox', + 'redry', + 'redub', + 'redux', + 'redye', + 'reech', + 'reede', + 'reeds', + 'reefs', + 'reefy', + 'reeks', + 'reeky', + 'reels', + 'reens', + 'reest', + 'reeve', + 'refed', + 'refel', + 'reffo', + 'refis', + 'refix', + 'refly', + 'refry', + 'regar', + 'reges', + 'reggo', + 'regie', + 'regma', + 'regna', + 'regos', + 'regur', + 'rehem', + 'reifs', + 'reify', + 'reiki', + 'reiks', + 'reink', + 'reins', + 'reird', + 'reist', + 'reive', + 'rejig', + 'rejon', + 'reked', + 'rekes', + 'rekey', + 'relet', + 'relie', + 'relit', + 'rello', + 'reman', + 'remap', + 'remen', + 'remet', + 'remex', + 'remix', + 'renay', + 'rends', + 'reney', + 'renga', + 'renig', + 'renin', + 'renne', + 'renos', + 'rente', + 'rents', + 'reoil', + 'reorg', + 'repeg', + 'repin', + 'repla', + 'repos', + 'repot', + 'repps', + 'repro', + 'reran', + 'rerig', + 'resat', + 'resaw', + 'resay', + 'resee', + 'reses', + 'resew', + 'resid', + 'resit', + 'resod', + 'resow', + 'resto', + 'rests', + 'resty', + 'resus', + 'retag', + 'retax', + 'retem', + 'retia', + 'retie', + 'retox', + 'revet', + 'revie', + 'rewan', + 'rewax', + 'rewed', + 'rewet', + 'rewin', + 'rewon', + 'rewth', + 'rexes', + 'rezes', + 'rheas', + 'rheme', + 'rheum', + 'rhies', + 'rhime', + 'rhine', + 'rhody', + 'rhomb', + 'rhone', + 'rhumb', + 'rhyne', + 'rhyta', + 'riads', + 'rials', + 'riant', + 'riata', + 'ribas', + 'ribby', + 'ribes', + 'riced', + 'ricer', + 'rices', + 'ricey', + 'richt', + 'ricin', + 'ricks', + 'rides', + 'ridgy', + 'ridic', + 'riels', + 'riems', + 'rieve', + 'rifer', + 'riffs', + 'rifte', + 'rifts', + 'rifty', + 'riggs', + 'rigol', + 'riled', + 'riles', + 'riley', + 'rille', + 'rills', + 'rimae', + 'rimed', + 'rimer', + 'rimes', + 'rimus', + 'rinds', + 'rindy', + 'rines', + 'rings', + 'rinks', + 'rioja', + 'riots', + 'riped', + 'ripes', + 'ripps', + 'rises', + 'rishi', + 'risks', + 'risps', + 'risus', + 'rites', + 'ritts', + 'ritzy', + 'rivas', + 'rived', + 'rivel', + 'riven', + 'rives', + 'riyal', + 'rizas', + 'roads', + 'roams', + 'roans', + 'roars', + 'roary', + 'roate', + 'robed', + 'robes', + 'roble', + 'rocks', + 'roded', + 'rodes', + 'roguy', + 'rohes', + 'roids', + 'roils', + 'roily', + 'roins', + 'roist', + 'rojak', + 'rojis', + 'roked', + 'roker', + 'rokes', + 'rolag', + 'roles', + 'rolfs', + 'rolls', + 'romal', + 'roman', + 'romeo', + 'romps', + 'ronde', + 'rondo', + 'roneo', + 'rones', + 'ronin', + 'ronne', + 'ronte', + 'ronts', + 'roods', + 'roofs', + 'roofy', + 'rooks', + 'rooky', + 'rooms', + 'roons', + 'roops', + 'roopy', + 'roosa', + 'roose', + 'roots', + 'rooty', + 'roped', + 'roper', + 'ropes', + 'ropey', + 'roque', + 'roral', + 'rores', + 'roric', + 'rorid', + 'rorie', + 'rorts', + 'rorty', + 'rosed', + 'roses', + 'roset', + 'roshi', + 'rosin', + 'rosit', + 'rosti', + 'rosts', + 'rotal', + 'rotan', + 'rotas', + 'rotch', + 'roted', + 'rotes', + 'rotis', + 'rotls', + 'roton', + 'rotos', + 'rotte', + 'rouen', + 'roues', + 'roule', + 'rouls', + 'roums', + 'roups', + 'roupy', + 'roust', + 'routh', + 'routs', + 'roved', + 'roven', + 'roves', + 'rowan', + 'rowed', + 'rowel', + 'rowen', + 'rowie', + 'rowme', + 'rownd', + 'rowth', + 'rowts', + 'royne', + 'royst', + 'rozet', + 'rozit', + 'ruana', + 'rubai', + 'rubby', + 'rubel', + 'rubes', + 'rubin', + 'ruble', + 'rubli', + 'rubus', + 'ruche', + 'rucks', + 'rudas', + 'rudds', + 'rudes', + 'rudie', + 'rudis', + 'rueda', + 'ruers', + 'ruffe', + 'ruffs', + 'rugae', + 'rugal', + 'ruggy', + 'ruing', + 'ruins', + 'rukhs', + 'ruled', + 'rules', + 'rumal', + 'rumbo', + 'rumen', + 'rumes', + 'rumly', + 'rummy', + 'rumpo', + 'rumps', + 'rumpy', + 'runch', + 'runds', + 'runed', + 'runes', + 'rungs', + 'runic', + 'runny', + 'runts', + 'runty', + 'rupia', + 'rurps', + 'rurus', + 'rusas', + 'ruses', + 'rushy', + 'rusks', + 'rusma', + 'russe', + 'rusts', + 'ruths', + 'rutin', + 'rutty', + 'ryals', + 'rybat', + 'ryked', + 'rykes', + 'rymme', + 'rynds', + 'ryots', + 'ryper', + 'saags', + 'sabal', + 'sabed', + 'saber', + 'sabes', + 'sabha', + 'sabin', + 'sabir', + 'sable', + 'sabot', + 'sabra', + 'sabre', + 'sacks', + 'sacra', + 'saddo', + 'sades', + 'sadhe', + 'sadhu', + 'sadis', + 'sados', + 'sadza', + 'safed', + 'safes', + 'sagas', + 'sager', + 'sages', + 'saggy', + 'sagos', + 'sagum', + 'saheb', + 'sahib', + 'saice', + 'saick', + 'saics', + 'saids', + 'saiga', + 'sails', + 'saims', + 'saine', + 'sains', + 'sairs', + 'saist', + 'saith', + 'sajou', + 'sakai', + 'saker', + 'sakes', + 'sakia', + 'sakis', + 'sakti', + 'salal', + 'salat', + 'salep', + 'sales', + 'salet', + 'salic', + 'salix', + 'salle', + 'salmi', + 'salol', + 'salop', + 'salpa', + 'salps', + 'salse', + 'salto', + 'salts', + 'salue', + 'salut', + 'saman', + 'samas', + 'samba', + 'sambo', + 'samek', + 'samel', + 'samen', + 'sames', + 'samey', + 'samfu', + 'sammy', + 'sampi', + 'samps', + 'sands', + 'saned', + 'sanes', + 'sanga', + 'sangh', + 'sango', + 'sangs', + 'sanko', + 'sansa', + 'santo', + 'sants', + 'saola', + 'sapan', + 'sapid', + 'sapor', + 'saran', + 'sards', + 'sared', + 'saree', + 'sarge', + 'sargo', + 'sarin', + 'saris', + 'sarks', + 'sarky', + 'sarod', + 'saros', + 'sarus', + 'saser', + 'sasin', + 'sasse', + 'satai', + 'satay', + 'sated', + 'satem', + 'sates', + 'satis', + 'sauba', + 'sauch', + 'saugh', + 'sauls', + 'sault', + 'saunt', + 'saury', + 'sauts', + 'saved', + 'saver', + 'saves', + 'savey', + 'savin', + 'sawah', + 'sawed', + 'sawer', + 'saxes', + 'sayed', + 'sayer', + 'sayid', + 'sayne', + 'sayon', + 'sayst', + 'sazes', + 'scabs', + 'scads', + 'scaff', + 'scags', + 'scail', + 'scala', + 'scall', + 'scams', + 'scand', + 'scans', + 'scapa', + 'scape', + 'scapi', + 'scarp', + 'scars', + 'scart', + 'scath', + 'scats', + 'scatt', + 'scaud', + 'scaup', + 'scaur', + 'scaws', + 'sceat', + 'scena', + 'scend', + 'schav', + 'schmo', + 'schul', + 'schwa', + 'sclim', + 'scody', + 'scogs', + 'scoog', + 'scoot', + 'scopa', + 'scops', + 'scots', + 'scoug', + 'scoup', + 'scowp', + 'scows', + 'scrab', + 'scrae', + 'scrag', + 'scran', + 'scrat', + 'scraw', + 'scray', + 'scrim', + 'scrip', + 'scrob', + 'scrod', + 'scrog', + 'scrow', + 'scudi', + 'scudo', + 'scuds', + 'scuff', + 'scuft', + 'scugs', + 'sculk', + 'scull', + 'sculp', + 'sculs', + 'scums', + 'scups', + 'scurf', + 'scurs', + 'scuse', + 'scuta', + 'scute', + 'scuts', + 'scuzz', + 'scyes', + 'sdayn', + 'sdein', + 'seals', + 'seame', + 'seams', + 'seamy', + 'seans', + 'seare', + 'sears', + 'sease', + 'seats', + 'seaze', + 'sebum', + 'secco', + 'sechs', + 'sects', + 'seder', + 'sedes', + 'sedge', + 'sedgy', + 'sedum', + 'seeds', + 'seeks', + 'seeld', + 'seels', + 'seely', + 'seems', + 'seeps', + 'seepy', + 'seers', + 'sefer', + 'segar', + 'segni', + 'segno', + 'segol', + 'segos', + 'sehri', + 'seifs', + 'seils', + 'seine', + 'seirs', + 'seise', + 'seism', + 'seity', + 'seiza', + 'sekos', + 'sekts', + 'selah', + 'seles', + 'selfs', + 'sella', + 'selle', + 'sells', + 'selva', + 'semee', + 'semes', + 'semie', + 'semis', + 'senas', + 'sends', + 'senes', + 'sengi', + 'senna', + 'senor', + 'sensa', + 'sensi', + 'sente', + 'senti', + 'sents', + 'senvy', + 'senza', + 'sepad', + 'sepal', + 'sepic', + 'sepoy', + 'septa', + 'septs', + 'serac', + 'serai', + 'seral', + 'sered', + 'serer', + 'seres', + 'serfs', + 'serge', + 'seric', + 'serin', + 'serks', + 'seron', + 'serow', + 'serra', + 'serre', + 'serrs', + 'serry', + 'servo', + 'sesey', + 'sessa', + 'setae', + 'setal', + 'seton', + 'setts', + 'sewan', + 'sewar', + 'sewed', + 'sewel', + 'sewen', + 'sewin', + 'sexed', + 'sexer', + 'sexes', + 'sexto', + 'sexts', + 'seyen', + 'shads', + 'shags', + 'shahs', + 'shako', + 'shakt', + 'shalm', + 'shaly', + 'shama', + 'shams', + 'shand', + 'shans', + 'shaps', + 'sharn', + 'shash', + 'shaul', + 'shawm', + 'shawn', + 'shaws', + 'shaya', + 'shays', + 'shchi', + 'sheaf', + 'sheal', + 'sheas', + 'sheds', + 'sheel', + 'shend', + 'shent', + 'sheol', + 'sherd', + 'shere', + 'shero', + 'shets', + 'sheva', + 'shewn', + 'shews', + 'shiai', + 'shiel', + 'shier', + 'shies', + 'shill', + 'shily', + 'shims', + 'shins', + 'ships', + 'shirr', + 'shirs', + 'shish', + 'shiso', + 'shist', + 'shite', + 'shits', + 'shiur', + 'shiva', + 'shive', + 'shivs', + 'shlep', + 'shlub', + 'shmek', + 'shmoe', + 'shoat', + 'shoed', + 'shoer', + 'shoes', + 'shogi', + 'shogs', + 'shoji', + 'shojo', + 'shola', + 'shool', + 'shoon', + 'shoos', + 'shope', + 'shops', + 'shorl', + 'shote', + 'shots', + 'shott', + 'showd', + 'shows', + 'shoyu', + 'shred', + 'shris', + 'shrow', + 'shtik', + 'shtum', + 'shtup', + 'shule', + 'shuln', + 'shuls', + 'shuns', + 'shura', + 'shute', + 'shuts', + 'shwas', + 'shyer', + 'sials', + 'sibbs', + 'sibyl', + 'sices', + 'sicht', + 'sicko', + 'sicks', + 'sicky', + 'sidas', + 'sided', + 'sider', + 'sides', + 'sidha', + 'sidhe', + 'sidle', + 'sield', + 'siens', + 'sient', + 'sieth', + 'sieur', + 'sifts', + 'sighs', + 'sigil', + 'sigla', + 'signa', + 'signs', + 'sijos', + 'sikas', + 'siker', + 'sikes', + 'silds', + 'siled', + 'silen', + 'siler', + 'siles', + 'silex', + 'silks', + 'sills', + 'silos', + 'silts', + 'silty', + 'silva', + 'simar', + 'simas', + 'simba', + 'simis', + 'simps', + 'simul', + 'sinds', + 'sined', + 'sines', + 'sings', + 'sinhs', + 'sinks', + 'sinky', + 'sinus', + 'siped', + 'sipes', + 'sippy', + 'sired', + 'siree', + 'sires', + 'sirih', + 'siris', + 'siroc', + 'sirra', + 'sirup', + 'sisal', + 'sises', + 'sista', + 'sists', + 'sitar', + 'sited', + 'sites', + 'sithe', + 'sitka', + 'situp', + 'situs', + 'siver', + 'sixer', + 'sixes', + 'sixmo', + 'sixte', + 'sizar', + 'sized', + 'sizel', + 'sizer', + 'sizes', + 'skags', + 'skail', + 'skald', + 'skank', + 'skart', + 'skats', + 'skatt', + 'skaws', + 'skean', + 'skear', + 'skeds', + 'skeed', + 'skeef', + 'skeen', + 'skeer', + 'skees', + 'skeet', + 'skegg', + 'skegs', + 'skein', + 'skelf', + 'skell', + 'skelm', + 'skelp', + 'skene', + 'skens', + 'skeos', + 'skeps', + 'skers', + 'skets', + 'skews', + 'skids', + 'skied', + 'skies', + 'skiey', + 'skimo', + 'skims', + 'skink', + 'skins', + 'skint', + 'skios', + 'skips', + 'skirl', + 'skirr', + 'skite', + 'skits', + 'skive', + 'skivy', + 'sklim', + 'skoal', + 'skody', + 'skoff', + 'skogs', + 'skols', + 'skool', + 'skort', + 'skosh', + 'skran', + 'skrik', + 'skuas', + 'skugs', + 'skyed', + 'skyer', + 'skyey', + 'skyfs', + 'skyre', + 'skyrs', + 'skyte', + 'slabs', + 'slade', + 'slaes', + 'slags', + 'slaid', + 'slake', + 'slams', + 'slane', + 'slank', + 'slaps', + 'slart', + 'slats', + 'slaty', + 'slaws', + 'slays', + 'slebs', + 'sleds', + 'sleer', + 'slews', + 'sleys', + 'slier', + 'slily', + 'slims', + 'slipe', + 'slips', + 'slipt', + 'slish', + 'slits', + 'slive', + 'sloan', + 'slobs', + 'sloes', + 'slogs', + 'sloid', + 'slojd', + 'slomo', + 'sloom', + 'sloot', + 'slops', + 'slopy', + 'slorm', + 'slots', + 'slove', + 'slows', + 'sloyd', + 'slubb', + 'slubs', + 'slued', + 'slues', + 'sluff', + 'slugs', + 'sluit', + 'slums', + 'slurb', + 'slurs', + 'sluse', + 'sluts', + 'slyer', + 'slype', + 'smaak', + 'smaik', + 'smalm', + 'smalt', + 'smarm', + 'smaze', + 'smeek', + 'smees', + 'smeik', + 'smeke', + 'smerk', + 'smews', + 'smirr', + 'smirs', + 'smits', + 'smogs', + 'smoko', + 'smolt', + 'smoor', + 'smoot', + 'smore', + 'smorg', + 'smout', + 'smowt', + 'smugs', + 'smurs', + 'smush', + 'smuts', + 'snabs', + 'snafu', + 'snags', + 'snaps', + 'snarf', + 'snark', + 'snars', + 'snary', + 'snash', + 'snath', + 'snaws', + 'snead', + 'sneap', + 'snebs', + 'sneck', + 'sneds', + 'sneed', + 'snees', + 'snell', + 'snibs', + 'snick', + 'snies', + 'snift', + 'snigs', + 'snips', + 'snipy', + 'snirt', + 'snits', + 'snobs', + 'snods', + 'snoek', + 'snoep', + 'snogs', + 'snoke', + 'snood', + 'snook', + 'snool', + 'snoot', + 'snots', + 'snowk', + 'snows', + 'snubs', + 'snugs', + 'snush', + 'snyes', + 'soaks', + 'soaps', + 'soare', + 'soars', + 'soave', + 'sobas', + 'socas', + 'soces', + 'socko', + 'socks', + 'socle', + 'sodas', + 'soddy', + 'sodic', + 'sodom', + 'sofar', + 'sofas', + 'softa', + 'softs', + 'softy', + 'soger', + 'sohur', + 'soils', + 'soily', + 'sojas', + 'sojus', + 'sokah', + 'soken', + 'sokes', + 'sokol', + 'solah', + 'solan', + 'solas', + 'solde', + 'soldi', + 'soldo', + 'solds', + 'soled', + 'solei', + 'soler', + 'soles', + 'solon', + 'solos', + 'solum', + 'solus', + 'soman', + 'somas', + 'sonce', + 'sonde', + 'sones', + 'songs', + 'sonly', + 'sonne', + 'sonny', + 'sonse', + 'sonsy', + 'sooey', + 'sooks', + 'sooky', + 'soole', + 'sools', + 'sooms', + 'soops', + 'soote', + 'soots', + 'sophs', + 'sophy', + 'sopor', + 'soppy', + 'sopra', + 'soral', + 'soras', + 'sorbo', + 'sorbs', + 'sorda', + 'sordo', + 'sords', + 'sored', + 'soree', + 'sorel', + 'sorer', + 'sores', + 'sorex', + 'sorgo', + 'sorns', + 'sorra', + 'sorta', + 'sorts', + 'sorus', + 'soths', + 'sotol', + 'souce', + 'souct', + 'sough', + 'souks', + 'souls', + 'soums', + 'soups', + 'soupy', + 'sours', + 'souse', + 'souts', + 'sowar', + 'sowce', + 'sowed', + 'sowff', + 'sowfs', + 'sowle', + 'sowls', + 'sowms', + 'sownd', + 'sowne', + 'sowps', + 'sowse', + 'sowth', + 'soyas', + 'soyle', + 'soyuz', + 'sozin', + 'spacy', + 'spado', + 'spaed', + 'spaer', + 'spaes', + 'spags', + 'spahi', + 'spail', + 'spain', + 'spait', + 'spake', + 'spald', + 'spale', + 'spall', + 'spalt', + 'spams', + 'spane', + 'spang', + 'spans', + 'spard', + 'spars', + 'spart', + 'spate', + 'spats', + 'spaul', + 'spawl', + 'spaws', + 'spayd', + 'spays', + 'spaza', + 'spazz', + 'speal', + 'spean', + 'speat', + 'specs', + 'spect', + 'speel', + 'speer', + 'speil', + 'speir', + 'speks', + 'speld', + 'spelk', + 'speos', + 'spets', + 'speug', + 'spews', + 'spewy', + 'spial', + 'spica', + 'spick', + 'spics', + 'spide', + 'spier', + 'spies', + 'spiff', + 'spifs', + 'spiks', + 'spile', + 'spims', + 'spina', + 'spink', + 'spins', + 'spirt', + 'spiry', + 'spits', + 'spitz', + 'spivs', + 'splay', + 'splog', + 'spode', + 'spods', + 'spoom', + 'spoor', + 'spoot', + 'spork', + 'sposh', + 'spots', + 'sprad', + 'sprag', + 'sprat', + 'spred', + 'sprew', + 'sprit', + 'sprod', + 'sprog', + 'sprue', + 'sprug', + 'spuds', + 'spued', + 'spuer', + 'spues', + 'spugs', + 'spule', + 'spume', + 'spumy', + 'spurs', + 'sputa', + 'spyal', + 'spyre', + 'squab', + 'squaw', + 'squeg', + 'squid', + 'squit', + 'squiz', + 'stabs', + 'stade', + 'stags', + 'stagy', + 'staig', + 'stane', + 'stang', + 'staph', + 'staps', + 'starn', + 'starr', + 'stars', + 'stats', + 'staun', + 'staws', + 'stays', + 'stean', + 'stear', + 'stedd', + 'stede', + 'steds', + 'steek', + 'steem', + 'steen', + 'steil', + 'stela', + 'stele', + 'stell', + 'steme', + 'stems', + 'stend', + 'steno', + 'stens', + 'stent', + 'steps', + 'stept', + 'stere', + 'stets', + 'stews', + 'stewy', + 'steys', + 'stich', + 'stied', + 'sties', + 'stilb', + 'stile', + 'stime', + 'stims', + 'stimy', + 'stipa', + 'stipe', + 'stire', + 'stirk', + 'stirp', + 'stirs', + 'stive', + 'stivy', + 'stoae', + 'stoai', + 'stoas', + 'stoat', + 'stobs', + 'stoep', + 'stogy', + 'stoit', + 'stoln', + 'stoma', + 'stond', + 'stong', + 'stonk', + 'stonn', + 'stook', + 'stoor', + 'stope', + 'stops', + 'stopt', + 'stoss', + 'stots', + 'stott', + 'stoun', + 'stoup', + 'stour', + 'stown', + 'stowp', + 'stows', + 'strad', + 'strae', + 'strag', + 'strak', + 'strep', + 'strew', + 'stria', + 'strig', + 'strim', + 'strop', + 'strow', + 'stroy', + 'strum', + 'stubs', + 'stude', + 'studs', + 'stull', + 'stulm', + 'stumm', + 'stums', + 'stuns', + 'stupa', + 'stupe', + 'sture', + 'sturt', + 'styed', + 'styes', + 'styli', + 'stylo', + 'styme', + 'stymy', + 'styre', + 'styte', + 'subah', + 'subas', + 'subby', + 'suber', + 'subha', + 'succi', + 'sucks', + 'sucky', + 'sucre', + 'sudds', + 'sudor', + 'sudsy', + 'suede', + 'suent', + 'suers', + 'suete', + 'suets', + 'suety', + 'sugan', + 'sughs', + 'sugos', + 'suhur', + 'suids', + 'suint', + 'suits', + 'sujee', + 'sukhs', + 'sukuk', + 'sulci', + 'sulfa', + 'sulfo', + 'sulks', + 'sulph', + 'sulus', + 'sumis', + 'summa', + 'sumos', + 'sumph', + 'sumps', + 'sunis', + 'sunks', + 'sunna', + 'sunns', + 'sunup', + 'supes', + 'supra', + 'surah', + 'sural', + 'suras', + 'surat', + 'surds', + 'sured', + 'sures', + 'surfs', + 'surfy', + 'surgy', + 'surra', + 'sused', + 'suses', + 'susus', + 'sutor', + 'sutra', + 'sutta', + 'swabs', + 'swack', + 'swads', + 'swage', + 'swags', + 'swail', + 'swain', + 'swale', + 'swaly', + 'swamy', + 'swang', + 'swank', + 'swans', + 'swaps', + 'swapt', + 'sward', + 'sware', + 'swarf', + 'swart', + 'swats', + 'swayl', + 'sways', + 'sweal', + 'swede', + 'sweed', + 'sweel', + 'sweer', + 'swees', + 'sweir', + 'swelt', + 'swerf', + 'sweys', + 'swies', + 'swigs', + 'swile', + 'swims', + 'swink', + 'swipe', + 'swire', + 'swiss', + 'swith', + 'swits', + 'swive', + 'swizz', + 'swobs', + 'swole', + 'swoln', + 'swops', + 'swopt', + 'swots', + 'swoun', + 'sybbe', + 'sybil', + 'syboe', + 'sybow', + 'sycee', + 'syces', + 'sycon', + 'syens', + 'syker', + 'sykes', + 'sylis', + 'sylph', + 'sylva', + 'symar', + 'synch', + 'syncs', + 'synds', + 'syned', + 'synes', + 'synth', + 'syped', + 'sypes', + 'syphs', + 'syrah', + 'syren', + 'sysop', + 'sythe', + 'syver', + 'taals', + 'taata', + 'taber', + 'tabes', + 'tabid', + 'tabis', + 'tabla', + 'tabor', + 'tabun', + 'tabus', + 'tacan', + 'taces', + 'tacet', + 'tache', + 'tacho', + 'tachs', + 'tacks', + 'tacos', + 'tacts', + 'taels', + 'tafia', + 'taggy', + 'tagma', + 'tahas', + 'tahrs', + 'taiga', + 'taigs', + 'taiko', + 'tails', + 'tains', + 'taira', + 'taish', + 'taits', + 'tajes', + 'takas', + 'takes', + 'takhi', + 'takin', + 'takis', + 'takky', + 'talak', + 'talaq', + 'talar', + 'talas', + 'talcs', + 'talcy', + 'talea', + 'taler', + 'tales', + 'talks', + 'talky', + 'talls', + 'talma', + 'talpa', + 'taluk', + 'talus', + 'tamal', + 'tamed', + 'tames', + 'tamin', + 'tamis', + 'tammy', + 'tamps', + 'tanas', + 'tanga', + 'tangi', + 'tangs', + 'tanhs', + 'tanka', + 'tanks', + 'tanky', + 'tanna', + 'tansy', + 'tanti', + 'tanto', + 'tanty', + 'tapas', + 'taped', + 'tapen', + 'tapes', + 'tapet', + 'tapis', + 'tappa', + 'tapus', + 'taras', + 'tardo', + 'tared', + 'tares', + 'targa', + 'targe', + 'tarns', + 'taroc', + 'tarok', + 'taros', + 'tarps', + 'tarre', + 'tarry', + 'tarsi', + 'tarts', + 'tarty', + 'tasar', + 'tased', + 'taser', + 'tases', + 'tasks', + 'tassa', + 'tasse', + 'tasso', + 'tatar', + 'tater', + 'tates', + 'taths', + 'tatie', + 'tatou', + 'tatts', + 'tatus', + 'taube', + 'tauld', + 'tauon', + 'taupe', + 'tauts', + 'tavah', + 'tavas', + 'taver', + 'tawai', + 'tawas', + 'tawed', + 'tawer', + 'tawie', + 'tawse', + 'tawts', + 'taxed', + 'taxer', + 'taxes', + 'taxis', + 'taxol', + 'taxon', + 'taxor', + 'taxus', + 'tayra', + 'tazza', + 'tazze', + 'teade', + 'teads', + 'teaed', + 'teaks', + 'teals', + 'teams', + 'tears', + 'teats', + 'teaze', + 'techs', + 'techy', + 'tecta', + 'teels', + 'teems', + 'teend', + 'teene', + 'teens', + 'teeny', + 'teers', + 'teffs', + 'teggs', + 'tegua', + 'tegus', + 'tehrs', + 'teiid', + 'teils', + 'teind', + 'teins', + 'telae', + 'telco', + 'teles', + 'telex', + 'telia', + 'telic', + 'tells', + 'telly', + 'teloi', + 'telos', + 'temed', + 'temes', + 'tempi', + 'temps', + 'tempt', + 'temse', + 'tench', + 'tends', + 'tendu', + 'tenes', + 'tenge', + 'tenia', + 'tenne', + 'tenno', + 'tenny', + 'tenon', + 'tents', + 'tenty', + 'tenue', + 'tepal', + 'tepas', + 'tepoy', + 'terai', + 'teras', + 'terce', + 'terek', + 'teres', + 'terfe', + 'terfs', + 'terga', + 'terms', + 'terne', + 'terns', + 'terry', + 'terts', + 'tesla', + 'testa', + 'teste', + 'tests', + 'tetes', + 'teths', + 'tetra', + 'tetri', + 'teuch', + 'teugh', + 'tewed', + 'tewel', + 'tewit', + 'texas', + 'texes', + 'texts', + 'thack', + 'thagi', + 'thaim', + 'thale', + 'thali', + 'thana', + 'thane', + 'thang', + 'thans', + 'thanx', + 'tharm', + 'thars', + 'thaws', + 'thawy', + 'thebe', + 'theca', + 'theed', + 'theek', + 'thees', + 'thegn', + 'theic', + 'thein', + 'thelf', + 'thema', + 'thens', + 'theow', + 'therm', + 'thesp', + 'thete', + 'thews', + 'thewy', + 'thigs', + 'thilk', + 'thill', + 'thine', + 'thins', + 'thiol', + 'thirl', + 'thoft', + 'thole', + 'tholi', + 'thoro', + 'thorp', + 'thous', + 'thowl', + 'thrae', + 'thraw', + 'thrid', + 'thrip', + 'throe', + 'thuds', + 'thugs', + 'thuja', + 'thunk', + 'thurl', + 'thuya', + 'thymi', + 'thymy', + 'tians', + 'tiars', + 'tical', + 'ticca', + 'ticed', + 'tices', + 'tichy', + 'ticks', + 'ticky', + 'tiddy', + 'tided', + 'tides', + 'tiers', + 'tiffs', + 'tifos', + 'tifts', + 'tiges', + 'tigon', + 'tikas', + 'tikes', + 'tikis', + 'tikka', + 'tilak', + 'tiled', + 'tiler', + 'tiles', + 'tills', + 'tilly', + 'tilth', + 'tilts', + 'timbo', + 'timed', + 'times', + 'timon', + 'timps', + 'tinas', + 'tinct', + 'tinds', + 'tinea', + 'tined', + 'tines', + 'tinge', + 'tings', + 'tinks', + 'tinny', + 'tints', + 'tinty', + 'tipis', + 'tippy', + 'tired', + 'tires', + 'tirls', + 'tiros', + 'tirrs', + 'titch', + 'titer', + 'titis', + 'titre', + 'titty', + 'titup', + 'tiyin', + 'tiyns', + 'tizes', + 'tizzy', + 'toads', + 'toady', + 'toaze', + 'tocks', + 'tocky', + 'tocos', + 'todde', + 'toeas', + 'toffs', + 'toffy', + 'tofts', + 'tofus', + 'togae', + 'togas', + 'toged', + 'toges', + 'togue', + 'tohos', + 'toile', + 'toils', + 'toing', + 'toise', + 'toits', + 'tokay', + 'toked', + 'toker', + 'tokes', + 'tokos', + 'tolan', + 'tolar', + 'tolas', + 'toled', + 'toles', + 'tolls', + 'tolly', + 'tolts', + 'tolus', + 'tolyl', + 'toman', + 'tombs', + 'tomes', + 'tomia', + 'tommy', + 'tomos', + 'tondi', + 'tondo', + 'toned', + 'toner', + 'tones', + 'toney', + 'tongs', + 'tonka', + 'tonks', + 'tonne', + 'tonus', + 'tools', + 'tooms', + 'toons', + 'toots', + 'toped', + 'topee', + 'topek', + 'toper', + 'topes', + 'tophe', + 'tophi', + 'tophs', + 'topis', + 'topoi', + 'topos', + 'toppy', + 'toque', + 'torah', + 'toran', + 'toras', + 'torcs', + 'tores', + 'toric', + 'torii', + 'toros', + 'torot', + 'torrs', + 'torse', + 'torsi', + 'torsk', + 'torta', + 'torte', + 'torts', + 'tosas', + 'tosed', + 'toses', + 'toshy', + 'tossy', + 'toted', + 'toter', + 'totes', + 'totty', + 'touks', + 'touns', + 'tours', + 'touse', + 'tousy', + 'touts', + 'touze', + 'touzy', + 'towed', + 'towie', + 'towns', + 'towny', + 'towse', + 'towsy', + 'towts', + 'towze', + 'towzy', + 'toyed', + 'toyer', + 'toyon', + 'toyos', + 'tozed', + 'tozes', + 'tozie', + 'trabs', + 'trads', + 'tragi', + 'traik', + 'trams', + 'trank', + 'tranq', + 'trans', + 'trant', + 'trape', + 'traps', + 'trapt', + 'trass', + 'trats', + 'tratt', + 'trave', + 'trayf', + 'trays', + 'treck', + 'treed', + 'treen', + 'trees', + 'trefa', + 'treif', + 'treks', + 'trema', + 'trems', + 'tress', + 'trest', + 'trets', + 'trews', + 'treyf', + 'treys', + 'triac', + 'tride', + 'trier', + 'tries', + 'triff', + 'trigo', + 'trigs', + 'trike', + 'trild', + 'trill', + 'trims', + 'trine', + 'trins', + 'triol', + 'trior', + 'trios', + 'trips', + 'tripy', + 'trist', + 'troad', + 'troak', + 'troat', + 'trock', + 'trode', + 'trods', + 'trogs', + 'trois', + 'troke', + 'tromp', + 'trona', + 'tronc', + 'trone', + 'tronk', + 'trons', + 'trooz', + 'troth', + 'trots', + 'trows', + 'troys', + 'trued', + 'trues', + 'trugo', + 'trugs', + 'trull', + 'tryer', + 'tryke', + 'tryma', + 'tryps', + 'tsade', + 'tsadi', + 'tsars', + 'tsked', + 'tsuba', + 'tsubo', + 'tuans', + 'tuart', + 'tuath', + 'tubae', + 'tubar', + 'tubas', + 'tubby', + 'tubed', + 'tubes', + 'tucks', + 'tufas', + 'tuffe', + 'tuffs', + 'tufts', + 'tufty', + 'tugra', + 'tuile', + 'tuina', + 'tuism', + 'tuktu', + 'tules', + 'tulpa', + 'tulsi', + 'tumid', + 'tummy', + 'tumps', + 'tumpy', + 'tunas', + 'tunds', + 'tuned', + 'tuner', + 'tunes', + 'tungs', + 'tunny', + 'tupek', + 'tupik', + 'tuple', + 'tuque', + 'turds', + 'turfs', + 'turfy', + 'turks', + 'turme', + 'turms', + 'turns', + 'turnt', + 'turps', + 'turrs', + 'tushy', + 'tusks', + 'tusky', + 'tutee', + 'tutti', + 'tutty', + 'tutus', + 'tuxes', + 'tuyer', + 'twaes', + 'twain', + 'twals', + 'twank', + 'twats', + 'tways', + 'tweel', + 'tween', + 'tweep', + 'tweer', + 'twerk', + 'twerp', + 'twier', + 'twigs', + 'twill', + 'twilt', + 'twink', + 'twins', + 'twiny', + 'twire', + 'twirp', + 'twite', + 'twits', + 'twoer', + 'twyer', + 'tyees', + 'tyers', + 'tyiyn', + 'tykes', + 'tyler', + 'tymps', + 'tynde', + 'tyned', + 'tynes', + 'typal', + 'typed', + 'types', + 'typey', + 'typic', + 'typos', + 'typps', + 'typto', + 'tyran', + 'tyred', + 'tyres', + 'tyros', + 'tythe', + 'tzars', + 'udals', + 'udons', + 'ugali', + 'ugged', + 'uhlan', + 'uhuru', + 'ukase', + 'ulama', + 'ulans', + 'ulema', + 'ulmin', + 'ulnad', + 'ulnae', + 'ulnar', + 'ulnas', + 'ulpan', + 'ulvas', + 'ulyie', + 'ulzie', + 'umami', + 'umbel', + 'umber', + 'umble', + 'umbos', + 'umbre', + 'umiac', + 'umiak', + 'umiaq', + 'ummah', + 'ummas', + 'ummed', + 'umped', + 'umphs', + 'umpie', + 'umpty', + 'umrah', + 'umras', + 'unais', + 'unapt', + 'unarm', + 'unary', + 'unaus', + 'unbag', + 'unban', + 'unbar', + 'unbed', + 'unbid', + 'unbox', + 'uncap', + 'unces', + 'uncia', + 'uncos', + 'uncoy', + 'uncus', + 'undam', + 'undee', + 'undos', + 'undug', + 'uneth', + 'unfix', + 'ungag', + 'unget', + 'ungod', + 'ungot', + 'ungum', + 'unhat', + 'unhip', + 'unica', + 'units', + 'unjam', + 'unked', + 'unket', + 'unkid', + 'unlaw', + 'unlay', + 'unled', + 'unlet', + 'unlid', + 'unman', + 'unmew', + 'unmix', + 'unpay', + 'unpeg', + 'unpen', + 'unpin', + 'unred', + 'unrid', + 'unrig', + 'unrip', + 'unsaw', + 'unsay', + 'unsee', + 'unsew', + 'unsex', + 'unsod', + 'untax', + 'untin', + 'unwet', + 'unwit', + 'unwon', + 'upbow', + 'upbye', + 'updos', + 'updry', + 'upend', + 'upjet', + 'uplay', + 'upled', + 'uplit', + 'upped', + 'upran', + 'uprun', + 'upsee', + 'upsey', + 'uptak', + 'upter', + 'uptie', + 'uraei', + 'urali', + 'uraos', + 'urare', + 'urari', + 'urase', + 'urate', + 'urbex', + 'urbia', + 'urdee', + 'ureal', + 'ureas', + 'uredo', + 'ureic', + 'urena', + 'urent', + 'urged', + 'urger', + 'urges', + 'urial', + 'urite', + 'urman', + 'urnal', + 'urned', + 'urped', + 'ursae', + 'ursid', + 'urson', + 'urubu', + 'urvas', + 'users', + 'usnea', + 'usque', + 'usure', + 'usury', + 'uteri', + 'uveal', + 'uveas', + 'uvula', + 'vacua', + 'vaded', + 'vades', + 'vagal', + 'vagus', + 'vails', + 'vaire', + 'vairs', + 'vairy', + 'vakas', + 'vakil', + 'vales', + 'valis', + 'valse', + 'vamps', + 'vampy', + 'vanda', + 'vaned', + 'vanes', + 'vangs', + 'vants', + 'vaped', + 'vaper', + 'vapes', + 'varan', + 'varas', + 'vardy', + 'varec', + 'vares', + 'varia', + 'varix', + 'varna', + 'varus', + 'varve', + 'vasal', + 'vases', + 'vasts', + 'vasty', + 'vatic', + 'vatus', + 'vauch', + 'vaute', + 'vauts', + 'vawte', + 'vaxes', + 'veale', + 'veals', + 'vealy', + 'veena', + 'veeps', + 'veers', + 'veery', + 'vegas', + 'veges', + 'vegie', + 'vegos', + 'vehme', + 'veils', + 'veily', + 'veins', + 'veiny', + 'velar', + 'velds', + 'veldt', + 'veles', + 'vells', + 'velum', + 'venae', + 'venal', + 'vends', + 'vendu', + 'veney', + 'venge', + 'venin', + 'vents', + 'venus', + 'verbs', + 'verra', + 'verry', + 'verst', + 'verts', + 'vertu', + 'vespa', + 'vesta', + 'vests', + 'vetch', + 'vexed', + 'vexer', + 'vexes', + 'vexil', + 'vezir', + 'vials', + 'viand', + 'vibes', + 'vibex', + 'vibey', + 'viced', + 'vices', + 'vichy', + 'viers', + 'views', + 'viewy', + 'vifda', + 'viffs', + 'vigas', + 'vigia', + 'vilde', + 'viler', + 'villi', + 'vills', + 'vimen', + 'vinal', + 'vinas', + 'vinca', + 'vined', + 'viner', + 'vines', + 'vinew', + 'vinic', + 'vinos', + 'vints', + 'viold', + 'viols', + 'vired', + 'vireo', + 'vires', + 'virga', + 'virge', + 'virid', + 'virls', + 'virtu', + 'visas', + 'vised', + 'vises', + 'visie', + 'visne', + 'vison', + 'visto', + 'vitae', + 'vitas', + 'vitex', + 'vitro', + 'vitta', + 'vivas', + 'vivat', + 'vivda', + 'viver', + 'vives', + 'vizir', + 'vizor', + 'vleis', + 'vlies', + 'vlogs', + 'voars', + 'vocab', + 'voces', + 'voddy', + 'vodou', + 'vodun', + 'voema', + 'vogie', + 'voids', + 'voile', + 'voips', + 'volae', + 'volar', + 'voled', + 'voles', + 'volet', + 'volks', + 'volta', + 'volte', + 'volti', + 'volts', + 'volva', + 'volve', + 'vomer', + 'voted', + 'votes', + 'vouge', + 'voulu', + 'vowed', + 'vower', + 'voxel', + 'vozhd', + 'vraic', + 'vrils', + 'vroom', + 'vrous', + 'vrouw', + 'vrows', + 'vuggs', + 'vuggy', + 'vughs', + 'vughy', + 'vulgo', + 'vulns', + 'vulva', + 'vutty', + 'waacs', + 'wacke', + 'wacko', + 'wacks', + 'wadds', + 'waddy', + 'waded', + 'wader', + 'wades', + 'wadge', + 'wadis', + 'wadts', + 'waffs', + 'wafts', + 'waged', + 'wages', + 'wagga', + 'wagyu', + 'wahoo', + 'waide', + 'waifs', + 'waift', + 'wails', + 'wains', + 'wairs', + 'waite', + 'waits', + 'wakas', + 'waked', + 'waken', + 'waker', + 'wakes', + 'wakfs', + 'waldo', + 'walds', + 'waled', + 'waler', + 'wales', + 'walie', + 'walis', + 'walks', + 'walla', + 'walls', + 'wally', + 'walty', + 'wamed', + 'wames', + 'wamus', + 'wands', + 'waned', + 'wanes', + 'waney', + 'wangs', + 'wanks', + 'wanky', + 'wanle', + 'wanly', + 'wanna', + 'wants', + 'wanty', + 'wanze', + 'waqfs', + 'warbs', + 'warby', + 'wards', + 'wared', + 'wares', + 'warez', + 'warks', + 'warms', + 'warns', + 'warps', + 'warre', + 'warst', + 'warts', + 'wases', + 'washy', + 'wasms', + 'wasps', + 'waspy', + 'wasts', + 'watap', + 'watts', + 'wauff', + 'waugh', + 'wauks', + 'waulk', + 'wauls', + 'waurs', + 'waved', + 'waves', + 'wavey', + 'wawas', + 'wawes', + 'wawls', + 'waxed', + 'waxer', + 'waxes', + 'wayed', + 'wazir', + 'wazoo', + 'weald', + 'weals', + 'weamb', + 'weans', + 'wears', + 'webby', + 'weber', + 'wecht', + 'wedel', + 'wedgy', + 'weeds', + 'weeke', + 'weeks', + 'weels', + 'weems', + 'weens', + 'weeny', + 'weeps', + 'weepy', + 'weest', + 'weete', + 'weets', + 'wefte', + 'wefts', + 'weids', + 'weils', + 'weirs', + 'weise', + 'weize', + 'wekas', + 'welds', + 'welke', + 'welks', + 'welkt', + 'wells', + 'welly', + 'welts', + 'wembs', + 'wends', + 'wenge', + 'wenny', + 'wents', + 'weros', + 'wersh', + 'wests', + 'wetas', + 'wetly', + 'wexed', + 'wexes', + 'whamo', + 'whams', + 'whang', + 'whaps', + 'whare', + 'whata', + 'whats', + 'whaup', + 'whaur', + 'wheal', + 'whear', + 'wheen', + 'wheep', + 'wheft', + 'whelk', + 'whelm', + 'whens', + 'whets', + 'whews', + 'wheys', + 'whids', + 'whift', + 'whigs', + 'whilk', + 'whims', + 'whins', + 'whios', + 'whips', + 'whipt', + 'whirr', + 'whirs', + 'whish', + 'whiss', + 'whist', + 'whits', + 'whity', + 'whizz', + 'whomp', + 'whoof', + 'whoot', + 'whops', + 'whore', + 'whorl', + 'whort', + 'whoso', + 'whows', + 'whump', + 'whups', + 'whyda', + 'wicca', + 'wicks', + 'wicky', + 'widdy', + 'wides', + 'wiels', + 'wifed', + 'wifes', + 'wifey', + 'wifie', + 'wifty', + 'wigan', + 'wigga', + 'wiggy', + 'wikis', + 'wilco', + 'wilds', + 'wiled', + 'wiles', + 'wilga', + 'wilis', + 'wilja', + 'wills', + 'wilts', + 'wimps', + 'winds', + 'wined', + 'wines', + 'winey', + 'winge', + 'wings', + 'wingy', + 'winks', + 'winna', + 'winns', + 'winos', + 'winze', + 'wiped', + 'wiper', + 'wipes', + 'wired', + 'wirer', + 'wires', + 'wirra', + 'wised', + 'wises', + 'wisha', + 'wisht', + 'wisps', + 'wists', + 'witan', + 'wited', + 'wites', + 'withe', + 'withs', + 'withy', + 'wived', + 'wiver', + 'wives', + 'wizen', + 'wizes', + 'woads', + 'woald', + 'wocks', + 'wodge', + 'woful', + 'wojus', + 'woker', + 'wokka', + 'wolds', + 'wolfs', + 'wolly', + 'wolve', + 'wombs', + 'womby', + 'womyn', + 'wonga', + 'wongi', + 'wonks', + 'wonky', + 'wonts', + 'woods', + 'wooed', + 'woofs', + 'woofy', + 'woold', + 'wools', + 'woons', + 'woops', + 'woopy', + 'woose', + 'woosh', + 'wootz', + 'words', + 'works', + 'worms', + 'wormy', + 'worts', + 'wowed', + 'wowee', + 'woxen', + 'wrang', + 'wraps', + 'wrapt', + 'wrast', + 'wrate', + 'wrawl', + 'wrens', + 'wrick', + 'wried', + 'wrier', + 'wries', + 'writs', + 'wroke', + 'wroot', + 'wroth', + 'wryer', + 'wuddy', + 'wudus', + 'wulls', + 'wurst', + 'wuses', + 'wushu', + 'wussy', + 'wuxia', + 'wyled', + 'wyles', + 'wynds', + 'wynns', + 'wyted', + 'wytes', + 'xebec', + 'xenia', + 'xenic', + 'xenon', + 'xeric', + 'xerox', + 'xerus', + 'xoana', + 'xrays', + 'xylan', + 'xylem', + 'xylic', + 'xylol', + 'xylyl', + 'xysti', + 'xysts', + 'yaars', + 'yabas', + 'yabba', + 'yabby', + 'yacca', + 'yacka', + 'yacks', + 'yaffs', + 'yager', + 'yages', + 'yagis', + 'yahoo', + 'yaird', + 'yakka', + 'yakow', + 'yales', + 'yamen', + 'yampy', + 'yamun', + 'yangs', + 'yanks', + 'yapok', + 'yapon', + 'yapps', + 'yappy', + 'yarak', + 'yarco', + 'yards', + 'yarer', + 'yarfa', + 'yarks', + 'yarns', + 'yarrs', + 'yarta', + 'yarto', + 'yates', + 'yauds', + 'yauld', + 'yaups', + 'yawed', + 'yawey', + 'yawls', + 'yawns', + 'yawny', + 'yawps', + 'ybore', + 'yclad', + 'ycled', + 'ycond', + 'ydrad', + 'ydred', + 'yeads', + 'yeahs', + 'yealm', + 'yeans', + 'yeard', + 'years', + 'yecch', + 'yechs', + 'yechy', + 'yedes', + 'yeeds', + 'yeesh', + 'yeggs', + 'yelks', + 'yells', + 'yelms', + 'yelps', + 'yelts', + 'yenta', + 'yente', + 'yerba', + 'yerds', + 'yerks', + 'yeses', + 'yesks', + 'yests', + 'yesty', + 'yetis', + 'yetts', + 'yeuks', + 'yeuky', + 'yeven', + 'yeves', + 'yewen', + 'yexed', + 'yexes', + 'yfere', + 'yiked', + 'yikes', + 'yills', + 'yince', + 'yipes', + 'yippy', + 'yirds', + 'yirks', + 'yirrs', + 'yirth', + 'yites', + 'yitie', + 'ylems', + 'ylike', + 'ylkes', + 'ymolt', + 'ympes', + 'yobbo', + 'yobby', + 'yocks', + 'yodel', + 'yodhs', + 'yodle', + 'yogas', + 'yogee', + 'yoghs', + 'yogic', + 'yogin', + 'yogis', + 'yoick', + 'yojan', + 'yoked', + 'yokel', + 'yoker', + 'yokes', + 'yokul', + 'yolks', + 'yolky', + 'yomim', + 'yomps', + 'yonic', + 'yonis', + 'yonks', + 'yoofs', + 'yoops', + 'yores', + 'yorks', + 'yorps', + 'youks', + 'yourn', + 'yours', + 'yourt', + 'youse', + 'yowed', + 'yowes', + 'yowie', + 'yowls', + 'yowza', + 'yrapt', + 'yrent', + 'yrivd', + 'yrneh', + 'ysame', + 'ytost', + 'yuans', + 'yucas', + 'yucca', + 'yucch', + 'yucko', + 'yucks', + 'yucky', + 'yufts', + 'yugas', + 'yuked', + 'yukes', + 'yukky', + 'yukos', + 'yulan', + 'yules', + 'yummo', + 'yummy', + 'yumps', + 'yupon', + 'yuppy', + 'yurta', + 'yurts', + 'yuzus', + 'zabra', + 'zacks', + 'zaida', + 'zaidy', + 'zaire', + 'zakat', + 'zaman', + 'zambo', + 'zamia', + 'zanja', + 'zante', + 'zanza', + 'zanze', + 'zappy', + 'zarfs', + 'zaris', + 'zatis', + 'zaxes', + 'zayin', + 'zazen', + 'zeals', + 'zebec', + 'zebub', + 'zebus', + 'zedas', + 'zeins', + 'zendo', + 'zerda', + 'zerks', + 'zeros', + 'zests', + 'zetas', + 'zexes', + 'zezes', + 'zhomo', + 'zibet', + 'ziffs', + 'zigan', + 'zilas', + 'zilch', + 'zilla', + 'zills', + 'zimbi', + 'zimbs', + 'zinco', + 'zincs', + 'zincy', + 'zineb', + 'zines', + 'zings', + 'zingy', + 'zinke', + 'zinky', + 'zippo', + 'zippy', + 'ziram', + 'zitis', + 'zizel', + 'zizit', + 'zlote', + 'zloty', + 'zoaea', + 'zobos', + 'zobus', + 'zocco', + 'zoeae', + 'zoeal', + 'zoeas', + 'zoism', + 'zoist', + 'zombi', + 'zonae', + 'zonda', + 'zoned', + 'zoner', + 'zones', + 'zonks', + 'zooea', + 'zooey', + 'zooid', + 'zooks', + 'zooms', + 'zoons', + 'zooty', + 'zoppa', + 'zoppo', + 'zoril', + 'zoris', + 'zorro', + 'zouks', + 'zowee', + 'zowie', + 'zulus', + 'zupan', + 'zupas', + 'zuppa', + 'zurfs', + 'zuzim', + 'zygal', + 'zygon', + 'zymes', + 'zymic', +]); diff --git a/examples/openapi-ts-tanstack-svelte-query/static/favicon.png b/examples/openapi-ts-tanstack-svelte-query/static/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..825b9e65af7c104cfb07089bb28659393b4f2097 GIT binary patch literal 1571 zcmeAS@N?(olHy`uVBq!ia0y~yU}ykg4i*LmhD`I74h#$ojKx9jP7LeL$-HD>V7=?< z;uunK>uv1q+}9QYp`3aLRhP6(c_0+yMGvW%`8w9Z4+AO$r=LiV^}WjuyMS z-`u@3yY$$SKDCAN>H9tj&u}g}XS4E2pY^*PkNZ3lroTLubH?oMf4#J9vzMpzCckct zowYnCeNLl>-tC#oR|mW7^83!__-WF*w@N!}ZnWO)*sV9e?K!tS_p_50%zk=doa_6a z9Ze7`Oq(1d_U2FyZ`xGx-xFfEE={d84w$f9rS697HscGE-dGl;{V=G?`XscL>&++e z>-U#%oq6{6`Q0U4b%OVNS0!jYj1*aM;g7Z{*A0W>9o{wqst=zQyeQ;ij+$byPs!T7 zP$;gE@43N(Z#KN^`%g~qnDC*fQ@9u5T z`010b%(4WBW*Igy)jqkB43?QUzqIP?pR?n;uR)>M{Z!UJzVqjLRQx?D9Xlud=JZMH zM4Dt}4@n0eu2Ixgk=cKk=N7x!uIU#Qr)QK{iRNADxA(7D>^{r+(1Q28%d+>r`1fM! z3!#PnEzgzrWhp(JYGANY`@x@o);^8RydN}I>CasHT;#z0|7n-*i5nc8wD_Qhgrn&1 z_=)HIc7)82SrZn{n5O;yq=&Wj!=(QfoT>{MZZVX#Y(9Ll{di*M8HGwlu2VN3EWtQvP&QN2PVR8N7!YC#E{m*$kY8i3^zQiv$JVzqYQu{#r;icEl z=UhCnkiGRom%yd1b*>!Dbz(=$xA=OCK9sWW?kjHnIi=(8N8<^v!`m)TWlU#3bX%EA zWW|L?Hd)uCpL{-aJW{t>_loq&RRZ@V7u56iZFu;9u7AgewTA2m_dYzmg!LfHN%jio z6)Tz8tu4PtytF=2_HyzK35Her8CehRz9{eceYP>8gyZOsf1e+R9eAyLo&U`AQ!>jL z>i##s-geN-*K&%b<6Sll}2Yvce^~*xG<6XX?1V3gp#~N zkiz|sN2i}Ey4w@5>yt(|hpKnhq#5tcY68zPo5(r8-F4X1_Ok2&?FGW>zrU(?x;Q#c?bx4-5dPgKtZr*@mZ=`3%X zy6%Z`^e5Hr^Y+>AzJm9>p2Z^BF4@_(4b1il6W?8xzhU;SdYz;2?R&rX$y{t=F!Y`E zR$}w<@9ihF9(X_5v`6rxTqRqD=!eToZeQ5@{QQC0#~w>6ukx<+wTnGF|CY_6xJ%zz zHr<`$x>nEcQ1ZHi?IAA|7rHVEt3Nz@U3=2vrr*f|MGoxkLSkxhhdzJg^6Z@Zq2`!6 zN9X(x&t6IHdUbyJoZ{}h2h3KD+a6rvIIkc7=B91g%$DcR#pk?L*qd_b^D~z6tu4>l zcb}QJe%gmWZyk5-zxe)Gtrh1xH}U_oBV*EcOaCc*(s}2g+Fj}Irl)7WovQcub7w{E upWAk8&OVF%_w#jD-*4ISJB6Y@xbv5oeJi^*U66r+fx*+&&t;ucLK6TBI`Z29 literal 0 HcmV?d00001 diff --git a/examples/openapi-ts-tanstack-svelte-query/static/robots.txt b/examples/openapi-ts-tanstack-svelte-query/static/robots.txt new file mode 100644 index 000000000..e9e57dc4d --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/static/robots.txt @@ -0,0 +1,3 @@ +# https://www.robotstxt.org/robotstxt.html +User-agent: * +Disallow: diff --git a/examples/openapi-ts-tanstack-svelte-query/svelte.config.js b/examples/openapi-ts-tanstack-svelte-query/svelte.config.js new file mode 100644 index 000000000..36b5795a1 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/svelte.config.js @@ -0,0 +1,18 @@ +import adapter from '@sveltejs/adapter-auto'; +import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'; + +/** @type {import('@sveltejs/kit').Config} */ +const config = { + kit: { + // adapter-auto only supports some environments, see https://kit.svelte.dev/docs/adapter-auto for a list. + // If your environment is not supported, or you settled on a specific environment, switch out the adapter. + // See https://kit.svelte.dev/docs/adapters for more information about adapters. + adapter: adapter(), + }, + + // Consult https://kit.svelte.dev/docs/integrations#preprocessors + // for more information about preprocessors + preprocess: vitePreprocess(), +}; + +export default config; diff --git a/examples/openapi-ts-tanstack-svelte-query/tsconfig.json b/examples/openapi-ts-tanstack-svelte-query/tsconfig.json new file mode 100644 index 000000000..593dc1963 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/tsconfig.json @@ -0,0 +1,19 @@ +{ + "extends": "./.svelte-kit/tsconfig.json", + "compilerOptions": { + "allowJs": true, + "checkJs": true, + "esModuleInterop": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "skipLibCheck": true, + "sourceMap": true, + "strict": true, + "moduleResolution": "bundler" + } + // Path aliases are handled by https://kit.svelte.dev/docs/configuration#alias + // except $lib which is handled by https://kit.svelte.dev/docs/configuration#files + // + // If you want to overwrite includes/excludes, make sure to copy over the relevant includes/excludes + // from the referenced tsconfig.json - TypeScript does not merge them in +} diff --git a/examples/openapi-ts-tanstack-svelte-query/vite.config.ts b/examples/openapi-ts-tanstack-svelte-query/vite.config.ts new file mode 100644 index 000000000..5edbb389f --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/vite.config.ts @@ -0,0 +1,9 @@ +import { sveltekit } from '@sveltejs/kit/vite'; +import { defineConfig } from 'vitest/config'; + +export default defineConfig({ + plugins: [sveltekit()], + test: { + include: ['src/**/*.{test,spec}.{js,ts}'], + }, +}); diff --git a/packages/openapi-ts/package.json b/packages/openapi-ts/package.json index badd36bf3..fced4d4d5 100644 --- a/packages/openapi-ts/package.json +++ b/packages/openapi-ts/package.json @@ -85,6 +85,8 @@ "@rollup/plugin-json": "6.1.0", "@rollup/plugin-node-resolve": "15.2.3", "@tanstack/react-query": "5.51.23", + "@tanstack/solid-query": "5.51.21", + "@tanstack/svelte-query": "5.51.21", "@tanstack/vue-query": "5.51.21", "@types/cross-spawn": "6.0.6", "@types/express": "4.17.21", diff --git a/packages/openapi-ts/src/generate/plugins.ts b/packages/openapi-ts/src/generate/plugins.ts index 3cee6f837..b0b95957a 100644 --- a/packages/openapi-ts/src/generate/plugins.ts +++ b/packages/openapi-ts/src/generate/plugins.ts @@ -64,6 +64,8 @@ export const generatePlugins = async ({ if ( plugin.name === '@tanstack/react-query' || + plugin.name === '@tanstack/solid-query' || + plugin.name === '@tanstack/svelte-query' || plugin.name === '@tanstack/vue-query' ) { const checkPrerequisites = ({ files }: { files: Files }) => { @@ -91,7 +93,11 @@ export const generatePlugins = async ({ const createQueryKeyParamsFn = 'createQueryKeyParams'; const infiniteQueryOptionsFn = 'infiniteQueryOptions'; - const mutationsType = 'UseMutationOptions'; + const mutationsType = + plugin.name === '@tanstack/svelte-query' || + plugin.name === '@tanstack/solid-query' + ? 'MutationOptions' + : 'UseMutationOptions'; const queryKeyName = 'QueryKey'; const queryOptionsFn = 'queryOptions'; const TOptionsType = 'TOptions'; diff --git a/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts index 80ba4121a..3df70a488 100644 --- a/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts +++ b/packages/openapi-ts/src/plugins/@tanstack/react-query/config.ts @@ -1,11 +1,11 @@ export interface PluginTanStackReactQuery { /** - * Generate {@link https://tanstack.com/query/latest/docs/framework/react/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected. + * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected. * @default true */ infiniteQueryOptions?: boolean; /** - * Generate {@link https://github.com/TanStack/query/blob/0696b514ce71dffc8acb38c55e0c93c43b781146/packages/react-query/src/types.ts#L128-L136 `mutationOptions()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. + * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/useMutation `useMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. * @default true */ mutationOptions?: boolean; @@ -19,7 +19,7 @@ export interface PluginTanStackReactQuery { */ output?: string; /** - * Generate {@link https://tanstack.com/query/latest/docs/framework/react/guides/query-options `queryOptions()`} helpers? + * Generate {@link https://tanstack.com/query/v5/docs/framework/react/reference/queryOptions `queryOptions()`} helpers? * These will be generated from all requests. * @default true */ diff --git a/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts new file mode 100644 index 000000000..c89de1b5a --- /dev/null +++ b/packages/openapi-ts/src/plugins/@tanstack/solid-query/config.ts @@ -0,0 +1,36 @@ +export interface PluginTanStackSolidQuery { + /** + * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected. + * @default true + */ + infiniteQueryOptions?: boolean; + /** + * Generate `createMutation()` helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. + * @default true + */ + mutationOptions?: boolean; + /** + * Generate TanStack Solid Query output from the provided input. + */ + name: '@tanstack/solid-query'; + /** + * Name of the generated file. + * @default '@tanstack/solid-query' + */ + output?: string; + /** + * Generate {@link https://tanstack.com/query/v5/docs/framework/solid/reference/createQuery `createQuery()`} helpers? + * These will be generated from all requests. + * @default true + */ + queryOptions?: boolean; +} + +export const pluginTanStackSolidQueryDefaultConfig: Required = + { + infiniteQueryOptions: true, + mutationOptions: true, + name: '@tanstack/solid-query', + output: '@tanstack/solid-query', + queryOptions: true, + }; diff --git a/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts new file mode 100644 index 000000000..17f10676f --- /dev/null +++ b/packages/openapi-ts/src/plugins/@tanstack/svelte-query/config.ts @@ -0,0 +1,36 @@ +export interface PluginTanStackSvelteQuery { + /** + * Generate `createInfiniteQuery()` helpers? These will be generated from GET and POST requests where a pagination parameter is detected. + * @default true + */ + infiniteQueryOptions?: boolean; + /** + * Generate {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createmutation `createMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. + * @default true + */ + mutationOptions?: boolean; + /** + * Generate TanStack Svelte Query output from the provided input. + */ + name: '@tanstack/svelte-query'; + /** + * Name of the generated file. + * @default '@tanstack/svelte-query' + */ + output?: string; + /** + * Generate {@link https://tanstack.com/query/v5/docs/framework/svelte/reference/functions/createquery `createQuery()`} helpers? + * These will be generated from all requests. + * @default true + */ + queryOptions?: boolean; +} + +export const pluginTanStackSvelteQueryDefaultConfig: Required = + { + infiniteQueryOptions: true, + mutationOptions: true, + name: '@tanstack/svelte-query', + output: '@tanstack/svelte-query', + queryOptions: true, + }; diff --git a/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts b/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts index 60a35ebba..4c29a07ed 100644 --- a/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts +++ b/packages/openapi-ts/src/plugins/@tanstack/vue-query/config.ts @@ -1,12 +1,11 @@ export interface PluginTanStackVueQuery { /** - * Generate {@link https://tanstack.com/query/latest/docs/framework/vue/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected. + * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/reference/infiniteQueryOptions `infiniteQueryOptions()`} helpers? These will be generated from GET and POST requests where a pagination parameter is detected. * @default true */ infiniteQueryOptions?: boolean; /** - * TODO: update link - * Generate {@link https://github.com/TanStack/query/blob/0696b514ce71dffc8acb38c55e0c93c43b781146/packages/react-query/src/types.ts#L128-L136 `mutationOptions()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. + * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/reference/useMutation `useMutation()`} helpers? These will be generated from DELETE, PATCH, POST, and PUT requests. * @default true */ mutationOptions?: boolean; @@ -20,7 +19,7 @@ export interface PluginTanStackVueQuery { */ output?: string; /** - * Generate {@link https://tanstack.com/query/latest/docs/framework/vue/guides/query-options `queryOptions()`} helpers? + * Generate {@link https://tanstack.com/query/v5/docs/framework/vue/guides/query-options `queryOptions()`} helpers? * These will be generated from all requests. * @default true */ diff --git a/packages/openapi-ts/src/plugins/index.ts b/packages/openapi-ts/src/plugins/index.ts index 490984f2c..981eeb346 100644 --- a/packages/openapi-ts/src/plugins/index.ts +++ b/packages/openapi-ts/src/plugins/index.ts @@ -2,12 +2,24 @@ import { type PluginTanStackReactQuery, pluginTanStackReactQueryDefaultConfig, } from './@tanstack/react-query/config'; +import { + type PluginTanStackSolidQuery, + pluginTanStackSolidQueryDefaultConfig, +} from './@tanstack/solid-query/config'; +import { + type PluginTanStackSvelteQuery, + pluginTanStackSvelteQueryDefaultConfig, +} from './@tanstack/svelte-query/config'; import { type PluginTanStackVueQuery, pluginTanStackVueQueryDefaultConfig, } from './@tanstack/vue-query/config'; -export type Plugins = PluginTanStackReactQuery | PluginTanStackVueQuery; +export type Plugins = + | PluginTanStackReactQuery + | PluginTanStackSolidQuery + | PluginTanStackSvelteQuery + | PluginTanStackVueQuery; type KeyTypes = string | number | symbol; @@ -26,5 +38,7 @@ type DefaultPluginConfigsMap< export const defaultPluginConfigs: DefaultPluginConfigsMap = { '@tanstack/react-query': pluginTanStackReactQueryDefaultConfig, + '@tanstack/solid-query': pluginTanStackSolidQueryDefaultConfig, + '@tanstack/svelte-query': pluginTanStackSvelteQueryDefaultConfig, '@tanstack/vue-query': pluginTanStackVueQueryDefaultConfig, }; diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap new file mode 100644 index 000000000..9b790fd5d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap @@ -0,0 +1,986 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type MutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/solid-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; +import type { AxiosError } from 'axios'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/services.gen.ts.snap new file mode 100644 index 000000000..c1ca53fa3 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-axios'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap new file mode 100644 index 000000000..8a73d3492 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap @@ -0,0 +1,109 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type MutationOptions } from '@tanstack/solid-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import type { AxiosError } from 'axios'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..e41163f6d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-axios'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-solid-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap new file mode 100644 index 000000000..d3281f8f4 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap @@ -0,0 +1,986 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type MutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/svelte-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; +import type { AxiosError } from 'axios'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/services.gen.ts.snap new file mode 100644 index 000000000..c1ca53fa3 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-axios'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap new file mode 100644 index 000000000..546f59dd6 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap @@ -0,0 +1,109 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type MutationOptions } from '@tanstack/svelte-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import type { AxiosError } from 'axios'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: MutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..e41163f6d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-axios'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-svelte-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap new file mode 100644 index 000000000..2d0fc6043 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap @@ -0,0 +1,986 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type UseMutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/vue-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; +import type { AxiosError } from 'axios'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, InfiniteData, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/services.gen.ts.snap new file mode 100644 index 000000000..c1ca53fa3 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-axios'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap new file mode 100644 index 000000000..ec71de425 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap @@ -0,0 +1,109 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-axios'; +import { queryOptions, type UseMutationOptions } from '@tanstack/vue-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import type { AxiosError } from 'axios'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: UseMutationOptions, Options> = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..e41163f6d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-axios'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-axios-plugin-tanstack-vue-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap new file mode 100644 index 000000000..10bc5c01b --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/@tanstack/solid-query.gen.ts.snap @@ -0,0 +1,985 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type MutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/solid-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/services.gen.ts.snap new file mode 100644 index 000000000..83a74f503 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-fetch'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap new file mode 100644 index 000000000..b2978509f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/@tanstack/solid-query.gen.ts.snap @@ -0,0 +1,108 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type MutationOptions } from '@tanstack/solid-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..fcb0cc83f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-fetch'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-solid-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap new file mode 100644 index 000000000..a4de7bcd2 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/@tanstack/svelte-query.gen.ts.snap @@ -0,0 +1,985 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type MutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/svelte-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: MutationOptions> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/services.gen.ts.snap new file mode 100644 index 000000000..83a74f503 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-fetch'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap new file mode 100644 index 000000000..e5a4cdf70 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/@tanstack/svelte-query.gen.ts.snap @@ -0,0 +1,108 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type MutationOptions } from '@tanstack/svelte-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: MutationOptions = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..fcb0cc83f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-fetch'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-svelte-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap new file mode 100644 index 000000000..7b809f418 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/@tanstack/vue-query.gen.ts.snap @@ -0,0 +1,985 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type UseMutationOptions, type DefaultError, infiniteQueryOptions, type InfiniteData } from '@tanstack/vue-query'; +import { export_, import_, apiVVersionOdataControllerCount, getCallWithoutParametersAndResponse, putCallWithoutParametersAndResponse, postCallWithoutParametersAndResponse, deleteCallWithoutParametersAndResponse, patchCallWithoutParametersAndResponse, deleteFoo, callWithDescriptions, deprecatedCall, callWithParameters, callWithWeirdParameterNames, getCallWithOptionalParam, postCallWithOptionalParam, postApiVbyApiVersionRequestBody, postApiVbyApiVersionFormData, callWithDefaultParameters, callWithDefaultOptionalParameters, callToTestOrderOfParams, duplicateName, duplicateName1, duplicateName2, duplicateName3, callWithNoContentResponse, callWithResponseAndNoContentResponse, dummyA, dummyB, callWithResponse, callWithDuplicateResponses, callWithResponses, collectionFormat, types, uploadFile, fileResponse, complexTypes, multipartRequest, multipartResponse, complexParams, callWithResultFromHeader, testErrorCode, nonAsciiæøåÆøÅöôêÊ字符串, putWithFormUrlEncoded } from '../services.gen'; +import type { ImportData, ImportError, ImportResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, ComplexTypesData, MultipartRequestData, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from '../types.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const exportOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await export_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'export' + } + ] +}); }; + +export const importOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await import_({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'import' + } + ] +}); }; + +export const importMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await import_({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const apiVVersionOdataControllerCountOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await apiVVersionOdataControllerCount({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'apiVVersionOdataControllerCount' + } + ] +}); }; + +export const getCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithoutParametersAndResponse' + } + ] +}); }; + +export const putCallWithoutParametersAndResponseMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await putCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postCallWithoutParametersAndResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithoutParametersAndResponse' + } + ] +}); }; + +export const postCallWithoutParametersAndResponseMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await postCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteCallWithoutParametersAndResponseMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await deleteCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const patchCallWithoutParametersAndResponseMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await patchCallWithoutParametersAndResponse({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deleteFooMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await deleteFoo({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDescriptionsOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDescriptions({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDescriptions' + } + ] +}); }; + +export const callWithDescriptionsMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDescriptions({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const deprecatedCallOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await deprecatedCall({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'deprecatedCall' + } + ] +}); }; + +export const deprecatedCallMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await deprecatedCall({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithParametersOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, string | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + cursor: pageParam + } + }; + const { data } = await callWithParameters({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'callWithParameters' + } + ] +}); }; + +export const callWithParametersMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithWeirdParameterNamesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithWeirdParameterNames' + } + ] +}); }; + +export const callWithWeirdParameterNamesMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithWeirdParameterNames({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const getCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await getCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const getCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + query: { + page: pageParam + } + }; + const { data } = await getCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'getCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postCallWithOptionalParam({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamInfiniteOptions = (options: Options) => { return infiniteQueryOptions, QueryKey>, number | QueryKey>[0]['params']>( +// @ts-ignore +{ + queryFn: async ({ pageParam, queryKey }) => { + // @ts-ignore + const page: QueryKey>[0]['params'] = typeof pageParam === "object" ? pageParam : { + body: { + offset: pageParam + } + }; + const { data } = await postCallWithOptionalParam({ + ...options, + body: { + ...queryKey[0].params.body as any, + ...page.body as any + }, + headers: { + ...queryKey[0].params.headers, + ...page.headers + }, + path: { + ...queryKey[0].params.path, + ...page.path + }, + query: { + ...queryKey[0].params.query, + ...page.query + }, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + infinite: true, + params: createQueryKeyParams(options), + scope: 'postCallWithOptionalParam' + } + ] +}); }; + +export const postCallWithOptionalParamMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await postCallWithOptionalParam({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionRequestBodyOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionRequestBody' + } + ] +}); }; + +export const postApiVbyApiVersionRequestBodyMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionRequestBody({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const postApiVbyApiVersionFormDataOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'postApiVbyApiVersionFormData' + } + ] +}); }; + +export const postApiVbyApiVersionFormDataMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await postApiVbyApiVersionFormData({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithDefaultParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDefaultOptionalParameters' + } + ] +}); }; + +export const callWithDefaultOptionalParametersMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await callWithDefaultOptionalParameters({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callToTestOrderOfParamsMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await callToTestOrderOfParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateNameOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName' + } + ] +}); }; + +export const duplicateName1Options = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await duplicateName1({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'duplicateName1' + } + ] +}); }; + +export const duplicateName1Mutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName1({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName2Mutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName2({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const duplicateName3Mutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await duplicateName3({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithNoContentResponse' + } + ] +}); }; + +export const callWithResponseAndNoContentResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponseAndNoContentResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponseAndNoContentResponse' + } + ] +}); }; + +export const dummyAOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyA({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyA' + } + ] +}); }; + +export const dummyBOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await dummyB({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'dummyB' + } + ] +}); }; + +export const callWithResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResponse' + } + ] +}); }; + +export const callWithDuplicateResponsesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithDuplicateResponses({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithDuplicateResponses' + } + ] +}); }; + +export const callWithDuplicateResponsesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithDuplicateResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResponsesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const collectionFormatOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await collectionFormat({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'collectionFormat' + } + ] +}); }; + +export const typesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await types({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'types' + } + ] +}); }; + +export const uploadFileOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await uploadFile({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'uploadFile' + } + ] +}); }; + +export const uploadFileMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await uploadFile({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const fileResponseOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await fileResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'fileResponse' + } + ] +}); }; + +export const complexTypesOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await complexTypes({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'complexTypes' + } + ] +}); }; + +export const multipartRequestOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartRequest({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartRequest' + } + ] +}); }; + +export const multipartRequestMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await multipartRequest({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipartResponseOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await multipartResponse({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'multipartResponse' + } + ] +}); }; + +export const complexParamsMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await complexParams({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const callWithResultFromHeaderOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await callWithResultFromHeader({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'callWithResultFromHeader' + } + ] +}); }; + +export const callWithResultFromHeaderMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await callWithResultFromHeader({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const testErrorCodeOptions = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await testErrorCode({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'testErrorCode' + } + ] +}); }; + +export const testErrorCodeMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await testErrorCode({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const nonAsciiæøåÆøÅöôêÊ字符串Options = (options: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'nonAsciiæøåÆøÅöôêÊ字符串' + } + ] +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串Mutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await nonAsciiæøåÆøÅöôêÊ字符串({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const putWithFormUrlEncodedMutation: UseMutationOptions> = { + mutationFn: async (options) => { + const { data } = await putWithFormUrlEncoded({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/services.gen.ts.snap new file mode 100644 index 000000000..83a74f503 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/services.gen.ts.snap @@ -0,0 +1,253 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options, formDataBodySerializer, urlSearchParamsBodySerializer } from '@hey-api/client-fetch'; +import type { ImportData, ImportError, ImportResponse, ApiVversionOdataControllerCountError, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamError, PostCallWithOptionalParamResponse, PostApiVbyApiVersionRequestBodyData, PostApiVbyApiVersionFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseError, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseError, CallWithResponseAndNoContentResponseResponse, DummyAError, DummyAResponse, DummyBError, DummyBResponse, CallWithResponseError, CallWithResponseResponse, CallWithDuplicateResponsesError, CallWithDuplicateResponsesResponse, CallWithResponsesError, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesError, TypesResponse, UploadFileData, UploadFileError, UploadFileResponse, FileResponseData, FileResponseError, FileResponseResponse, ComplexTypesData, ComplexTypesError, ComplexTypesResponse, MultipartRequestData, MultipartResponseError, MultipartResponseResponse, ComplexParamsData, ComplexParamsError, ComplexParamsResponse, CallWithResultFromHeaderError, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeError, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Error, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; + +export const client = createClient(createConfig()); + +export const export_ = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const import_ = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/no-tag' +}); }; + +export const apiVVersionOdataControllerCount = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple/$count' +}); }; + +export const getCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const putCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const postCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const optionsCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).options({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const headCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).head({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const patchCallWithoutParametersAndResponse = (options?: Options) => { return (options?.client ?? client).patch({ + ...options, + url: '/api/v{api-version}/simple' +}); }; + +export const deleteFoo = (options: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}' +}); }; + +export const callWithDescriptions = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/descriptions/' +}); }; + +/** + * @deprecated + */ +export const deprecatedCall = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/deprecated' +}); }; + +export const callWithParameters = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameterPath}' +}); }; + +export const callWithWeirdParameterNames = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}' +}); }; + +export const getCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postCallWithOptionalParam = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/parameters/' +}); }; + +export const postApiVbyApiVersionRequestBody = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/requestBody/' +}); }; + +export const postApiVbyApiVersionFormData = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/formData/' +}); }; + +export const callWithDefaultParameters = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callWithDefaultOptionalParameters = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const callToTestOrderOfParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/defaults' +}); }; + +export const duplicateName = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName1 = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName2 = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const duplicateName3 = (options?: Options) => { return (options?.client ?? client).delete({ + ...options, + url: '/api/v{api-version}/duplicate' +}); }; + +export const callWithNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/no-content' +}); }; + +export const callWithResponseAndNoContentResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/response-and-no-content' +}); }; + +export const dummyA = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/a' +}); }; + +export const dummyB = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multiple-tags/b' +}); }; + +export const callWithResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithDuplicateResponses = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const callWithResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/response' +}); }; + +export const collectionFormat = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/collectionFormat' +}); }; + +export const types = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/types' +}); }; + +export const uploadFile = (options: Options) => { return (options?.client ?? client).post({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/upload' +}); }; + +export const fileResponse = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/file/{id}' +}); }; + +export const complexTypes = (options: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/complex' +}); }; + +export const multipartRequest = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + ...formDataBodySerializer, + headers: { + 'Content-Type': null + }, + url: '/api/v{api-version}/multipart' +}); }; + +export const multipartResponse = (options?: Options) => { return (options?.client ?? client).get({ + ...options, + url: '/api/v{api-version}/multipart' +}); }; + +export const complexParams = (options: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/v{api-version}/complex/{id}' +}); }; + +export const callWithResultFromHeader = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/header' +}); }; + +export const testErrorCode = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/error' +}); }; + +export const nonAsciiæøåÆøÅöôêÊ字符串 = (options: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; + +/** + * Login User + */ +export const putWithFormUrlEncoded = (options: Options) => { return (options?.client ?? client).put({ + ...options, + ...urlSearchParamsBodySerializer, + headers: { + 'Content-Type': 'application/x-www-form-urlencoded' + }, + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/types.gen.ts.snap new file mode 100644 index 000000000..817014a4d --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query/types.gen.ts.snap @@ -0,0 +1,1581 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * Model with number-only name + */ +export type _400 = string; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type camelCaseCommentWithBreaks = number; + +/** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ +export type CommentWithBreaks = number; + +/** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ +export type CommentWithBackticks = number; + +/** + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work + */ +export type CommentWithBackticksAndQuotes = number; + +/** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ +export type CommentWithSlashes = number; + +/** + * Testing expression placeholders in string: ${expression} should work + */ +export type CommentWithExpressionPlaceholders = number; + +/** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ +export type CommentWithQuotes = number; + +/** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ +export type CommentWithReservedCharacters = number; + +/** + * This is a simple number + */ +export type SimpleInteger = number; + +/** + * This is a simple boolean + */ +export type SimpleBoolean = boolean; + +/** + * This is a simple string + */ +export type SimpleString = string; + +/** + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) + */ +export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; + +/** + * This is a simple file + */ +export type SimpleFile = (Blob | File); + +/** + * This is a simple reference + */ +export type SimpleReference = ModelWithString; + +/** + * This is a simple string + */ +export type SimpleStringWithPattern = string | null; + +/** + * This is a simple enum with strings + */ +export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; + +/** + * This is a simple enum with strings + */ +export const EnumWithStrings = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + NON_ASCII__ØÆÅÔÖ_ØÆÅÔÖ字符串: 'Non-ascii: øæåôöØÆÅÔÖ字符串' +} as const; + +export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; + +export const EnumWithReplacedCharacters = { + _SINGLE_QUOTE_: "'Single Quote'", + _DOUBLE_QUOTES_: '"Double Quotes"', + ØÆÅÔÖ_ØÆÅÔÖ字符串: 'øæåôöØÆÅÔÖ字符串', + '_3.1': 3.1, + EMPTY_STRING: '' +} as const; + +/** + * This is a simple enum with numbers + */ +export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; + +/** + * This is a simple enum with numbers + */ +export const EnumWithNumbers = { + '_1': 1, + '_2': 2, + '_3': 3, + '_1.1': 1.1, + '_1.2': 1.2, + '_1.3': 1.3, + '_100': 100, + '_200': 200, + '_300': 300, + '_-100': -100, + '_-200': -200, + '_-300': -300, + '_-1.1': -1.1, + '_-1.2': -1.2, + '_-1.3': -1.3 +} as const; + +/** + * Success=1,Warning=2,Error=3 + */ +export type EnumFromDescription = number; + +/** + * This is a simple enum with numbers + */ +export type EnumWithExtensions = 200 | 400 | 500; + +/** + * This is a simple enum with numbers + */ +export const EnumWithExtensions = { + /** + * Used when the status of something is successful + */ + CUSTOM_SUCCESS: 200, + /** + * Used when the status of something has a warning + */ + CUSTOM_WARNING: 400, + /** + * Used when the status of something has an error + */ + CUSTOM_ERROR: 500 +} as const; + +export type EnumWithXEnumNames = 0 | 1 | 2; + +export const EnumWithXEnumNames = { + zero: 0, + one: 1, + two: 2 +} as const; + +/** + * This is a simple array with numbers + */ +export type ArrayWithNumbers = Array<(number)>; + +/** + * This is a simple array with booleans + */ +export type ArrayWithBooleans = Array<(boolean)>; + +/** + * This is a simple array with strings + */ +export type ArrayWithStrings = Array<(string)>; + +/** + * This is a simple array with references + */ +export type ArrayWithReferences = Array; + +/** + * This is a simple array containing an array + */ +export type ArrayWithArray = Array>; + +/** + * This is a simple array with properties + */ +export type ArrayWithProperties = Array<{ + '16x16'?: camelCaseCommentWithBreaks; + bar?: string; +}>; + +/** + * This is a simple array with any of properties + */ +export type ArrayWithAnyOfProperties = Array<({ + foo?: string; +} | { + bar?: string; +})>; + +export type AnyOfAnyAndNull = { + data?: unknown | null; +}; + +/** + * This is a simple array with any of properties + */ +export type AnyOfArrays = { + results?: Array<({ + foo?: string; +} | { + bar?: string; +})>; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithString = { + [key: string]: (string); +}; + +export type DictionaryWithPropertiesAndAdditionalProperties = { + foo?: number; + bar?: boolean; + [key: string]: (string | number | boolean) | undefined; +}; + +/** + * This is a string reference + */ +export type DictionaryWithReference = { + [key: string]: ModelWithString; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithArray = { + [key: string]: Array; +}; + +/** + * This is a string dictionary + */ +export type DictionaryWithDictionary = { + [key: string]: { + [key: string]: (string); + }; +}; + +/** + * This is a complex dictionary + */ +export type DictionaryWithProperties = { + [key: string]: { + foo?: string; + bar?: string; + }; +}; + +/** + * This is a model with one number property + */ +export type ModelWithInteger = { + /** + * This is a simple number property + */ + prop?: number; +}; + +/** + * This is a model with one boolean property + */ +export type ModelWithBoolean = { + /** + * This is a simple boolean property + */ + prop?: boolean; +}; + +/** + * This is a model with one string property + */ +export type ModelWithString = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * This is a model with one string property + */ +export type ModelWithStringError = { + /** + * This is a simple string property + */ + prop?: string; +}; + +/** + * `Comment` or `VoiceComment`. The JSON object for adding voice comments to tickets is different. See [Adding voice comments to tickets](/documentation/ticketing/managing-tickets/adding-voice-comments-to-tickets) + */ +export type Model_From_Zendesk = string; + +/** + * This is a model with one string property + */ +export type ModelWithNullableString = { + /** + * This is a simple string property + */ + nullableProp1?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp1: string | null; + /** + * This is a simple string property + */ + nullableProp2?: string | null; + /** + * This is a simple string property + */ + nullableRequiredProp2: string | null; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a simple enum with strings + */ +export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + +/** + * This is a simple enum with strings + */ +export const foo_bar_enum = { + SUCCESS: 'Success', + WARNING: 'Warning', + ERROR: 'Error', + ØÆÅ字符串: 'ØÆÅ字符串' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnum = { + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; + /** + * These are the HTTP error code enums + */ + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + /** + * Simple boolean enum + */ + bool?: boolean; +}; + +/** + * These are the HTTP error code enums + */ +export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; + +/** + * These are the HTTP error code enums + */ +export const statusCode = { + _100: '100', + _200_FOO: '200 FOO', + _300_FOO_BAR: '300 FOO_BAR', + _400_FOO_BAR: '400 foo-bar', + _500_FOO_BAR: '500 foo.bar', + _600_FOO_BAR: '600 foo&bar' +} as const; + +/** + * This is a model with one enum with escaped name + */ +export type ModelWithEnumWithHyphen = { + 'foo-bar-baz-qux'?: '3.0'; +}; + +export type foo_bar_baz_qux = '3.0'; + +export const foo_bar_baz_qux = { + _3_0: '3.0' +} as const; + +/** + * This is a model with one enum + */ +export type ModelWithEnumFromDescription = { + /** + * Success=1,Warning=2,Error=3 + */ + test?: number; +}; + +/** + * This is a model with nested enums + */ +export type ModelWithNestedEnums = { + dictionaryWithEnum?: { + [key: string]: ('Success' | 'Warning' | 'Error'); + }; + dictionaryWithEnumFromDescription?: { + [key: string]: (number); + }; + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; + arrayWithDescription?: Array<(number)>; + /** + * This is a simple enum with strings + */ + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; +}; + +/** + * This is a model with one property containing a reference + */ +export type ModelWithReference = { + prop?: ModelWithProperties; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArrayReadOnlyAndWriteOnly = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing an array + */ +export type ModelWithArray = { + prop?: Array; + propWithFile?: Array<((Blob | File))>; + propWithNumber?: Array<(number)>; +}; + +/** + * This is a model with one property containing a dictionary + */ +export type ModelWithDictionary = { + prop?: { + [key: string]: (string); + }; +}; + +/** + * This is a deprecated model with a deprecated property + * @deprecated + */ +export type DeprecatedModel = { + /** + * This is a deprecated property + * @deprecated + */ + prop?: string; +}; + +/** + * This is a model with one property containing a circular reference + */ +export type ModelWithCircularReference = { + prop?: ModelWithCircularReference; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * Circle + */ +export type ModelCircle = { + kind: 'circle'; + radius?: number; +}; + +/** + * Square + */ +export type ModelSquare = { + kind: 'square'; + sideLength?: number; +}; + +/** + * This is a model with one property with a 'one of' relationship where the options are not $ref + */ +export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOf = { + propA?: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; +}; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithAnyOfAnonymous = { + propA?: { + propA?: string; +} | string | number; +}; + +/** + * This is a model with nested 'any of' property with a type null + */ +export type CompositionWithNestedAnyAndTypeNull = { + propA?: Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>; +}; + +export type _3e_num_1Период = 'Bird' | 'Dog'; + +export const _3e_num_1Период = { + BIRD: 'Bird', + DOG: 'Dog' +} as const; + +export type ConstValue = "ConstValue"; + +/** + * This is a model with one property with a 'any of' relationship where the options are not $ref + */ +export type CompositionWithNestedAnyOfAndNull = { + propA?: Array<(_3e_num_1Период | ConstValue)> | null; +}; + +/** + * This is a model with one property with a 'one of' relationship + */ +export type CompositionWithOneOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a model that contains a simple dictionary within composition + */ +export type CompositionWithOneOfAndSimpleDictionary = { + propA?: boolean | { + [key: string]: (number); +}; +}; + +/** + * This is a model that contains a dictionary of simple arrays within composition + */ +export type CompositionWithOneOfAndSimpleArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(boolean)>; +}; +}; + +/** + * This is a model that contains a dictionary of complex arrays (composited) within composition + */ +export type CompositionWithOneOfAndComplexArrayDictionary = { + propA?: boolean | { + [key: string]: Array<(number | string)>; +}; +}; + +/** + * This is a model with one property with a 'all of' relationship + */ +export type CompositionWithAllOfAndNullable = { + propA?: ({ + boolean?: boolean; +} & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null; +}; + +/** + * This is a model with one property with a 'any of' relationship + */ +export type CompositionWithAnyOfAndNullable = { + propA?: { + boolean?: boolean; +} | ModelWithEnum | ModelWithArray | ModelWithDictionary | null; +}; + +/** + * This is a base model with two simple optional properties + */ +export type CompositionBaseModel = { + firstName?: string; + lastname?: string; +}; + +/** + * This is a model that extends the base model + */ +export type CompositionExtendedModel = CompositionBaseModel & { + firstName: string; + lastname: string; + age: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithProperties = { + required: string; + readonly requiredAndReadOnly: string; + requiredAndNullable: string | null; + string?: string; + number?: number; + boolean?: boolean; + reference?: ModelWithString; + 'property with space'?: string; + default?: string; + try?: string; + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; +}; + +/** + * This is a model with one nested property + */ +export type ModelWithNestedProperties = { + readonly first: { + readonly second: { + readonly third: string | null; + } | null; + } | null; +}; + +/** + * This is a model with duplicated properties + */ +export type ModelWithDuplicateProperties = { + prop?: ModelWithString; +}; + +/** + * This is a model with ordered properties + */ +export type ModelWithOrderedProperties = { + zebra?: string; + apple?: string; + hawaii?: string; +}; + +/** + * This is a model with duplicated imports + */ +export type ModelWithDuplicateImports = { + propA?: ModelWithString; + propB?: ModelWithString; + propC?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtends = ModelWithString & { + propExtendsA?: string; + propExtendsB?: ModelWithString; +}; + +/** + * This is a model that extends another model + */ +export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { + propExtendsC?: string; + propExtendsD?: ModelWithString; +}; + +/** + * This is a model that contains a some patterns + */ +export type ModelWithPattern = { + key: string; + name: string; + readonly enabled?: boolean; + readonly modified?: string; + id?: string; + text?: string; + patternWithSingleQuotes?: string; + patternWithNewline?: string; + patternWithBacktick?: string; +}; + +export type File = { + readonly id?: string; + readonly updated_at?: string; + readonly created_at?: string; + mime: string; + readonly file?: string; +}; + +export type _default = { + name?: string; +}; + +export type Pageable = { + page?: number; + size?: number; + sort?: Array<(string)>; +}; + +/** + * This is a free-form object without additionalProperties. + */ +export type FreeFormObjectWithoutAdditionalProperties = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: true. + */ +export type FreeFormObjectWithAdditionalPropertiesEqTrue = { + [key: string]: unknown; +}; + +/** + * This is a free-form object with additionalProperties: {}. + */ +export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { + [key: string]: unknown; +}; + +export type ModelWithConst = { + String?: "String"; + number?: 0; + null?: null; + withType?: "Some string"; +}; + +/** + * This is a model with one property and additionalProperties: true + */ +export type ModelWithAdditionalPropertiesEqTrue = { + /** + * This is a simple string property + */ + prop?: string; + [key: string]: unknown | string; +}; + +export type NestedAnyOfArraysNullable = { + nullableArray?: Array<(string | boolean)> | null; +}; + +export type CompositionWithOneOfAndProperties = { + foo: ParameterSimpleParameter; +} | { + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; +} & { + baz: number | null; + qux: number; +}; + +/** + * An object that can be null + */ +export type NullableObject = { + foo?: string; +} | null; + +/** + * Some % character + */ +export type CharactersInDescription = string; + +export type ModelWithNullableObject = { + data?: NullableObject; +}; + +export type ModelWithOneOfEnum = { + foo: 'Bar'; +} | { + foo: 'Baz'; +} | { + foo: 'Qux'; +} | { + content: string; + foo: 'Quux'; +} | { + content: [ + string, + string + ]; + foo: 'Corge'; +}; + +export type foo = 'Bar'; + +export const foo = { + BAR: 'Bar' +} as const; + +export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; + +export const ModelWithNestedArrayEnumsDataFoo = { + FOO: 'foo', + BAR: 'bar' +} as const; + +export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; + +export const ModelWithNestedArrayEnumsDataBar = { + BAZ: 'baz', + QUX: 'qux' +} as const; + +export type ModelWithNestedArrayEnumsData = { + foo?: Array; + bar?: Array; +}; + +export type ModelWithNestedArrayEnums = { + array_strings?: Array<(string)>; + data?: ModelWithNestedArrayEnumsData; +}; + +export type ModelWithNestedCompositionEnums = { + foo?: ModelWithNestedArrayEnumsDataFoo; +}; + +export type ModelWithReadOnlyAndWriteOnly = { + foo: string; + readonly bar: string; + baz: string; +}; + +export type ModelWithConstantSizeArray = [ + number, + number +]; + +export type ModelWithAnyOfConstantSizeArray = [ + number | string, + number | string, + number | string +]; + +export type ModelWithPrefixItemsConstantSizeArray = [ + ModelWithInteger, + number | string, + string +]; + +export type ModelWithAnyOfConstantSizeArrayNullable = [ + number | null | string, + number | null | string, + number | null | string +]; + +export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ + number | _import, + number | _import +]; + +export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ + number & string, + number & string +]; + +export type ModelWithNumericEnumUnion = { + /** + * Период + */ + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; +}; + +/** + * Период + */ +export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; + +/** + * Период + */ +export const value = { + '_-10': -10, + '_-1': -1, + '_0': 0, + '_1': 1, + '_3': 3, + '_6': 6, + '_12': 12 +} as const; + +/** + * Some description with `back ticks` + */ +export type ModelWithBackticksInDescription = { + /** + * The template `that` should be used for parsing and importing the contents of the CSV file. + * + *

There is one placeholder currently supported:

  • ${x} - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)

Example of a correct JSON template:

+ * 
+     * [
+     * {
+     * "resourceType": "Asset",
+     * "identifier": {
+     * "name": "${1}",
+     * "domain": {
+     * "name": "${2}",
+     * "community": {
+     * "name": "Some Community"
+     * }
+     * }
+     * },
+     * "attributes" : {
+     * "00000000-0000-0000-0000-000000003115" : [ {
+     * "value" : "${3}"
+     * } ],
+     * "00000000-0000-0000-0000-000000000222" : [ {
+     * "value" : "${4}"
+     * } ]
+     * }
+     * }
+     * ]
+     *
+ */ + template?: string; +}; + +export type ModelWithOneOfAndProperties = ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串 & { + baz: number | null; + qux: number; +}; + +/** + * Model used to test deduplication strategy (unused) + */ +export type ParameterSimpleParameterUnused = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse = string; + +/** + * Model used to test deduplication strategy + */ +export type PostServiceWithEmptyTagResponse2 = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData = string; + +/** + * Model used to test deduplication strategy + */ +export type DeleteFooData2 = string; + +/** + * Model with restricted keyword name + */ +export type _import = string; + +export type SchemaWithFormRestrictedKeys = { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + object?: { + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; + }; + array?: Array<({ + description?: string; + 'x-enum-descriptions'?: string; + 'x-enum-varnames'?: string; + 'x-enumNames'?: string; + title?: string; +})>; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { + /** + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. + */ + preconditions?: io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions; +}; + +/** + * This schema was giving PascalCase transformations a hard time + */ +export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { + /** + * Specifies the target ResourceVersion + */ + resourceVersion?: string; + /** + * Specifies the target UID. + */ + uid?: string; +}; + +/** + * This is a reusable parameter + */ +export type ParameterSimpleParameter = string; + +/** + * Parameter with illegal characters + */ +export type Parameterx_Foo_Bar = ModelWithString; + +export type ImportData = { + body: ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly; +}; + +export type ImportResponse = Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly; + +export type ImportError = unknown; + +export type ApiVversionOdataControllerCountResponse = Model_From_Zendesk; + +export type ApiVversionOdataControllerCountError = unknown; + +export type DeleteFooData3 = { + headers: { + /** + * Parameter with illegal characters + */ + 'x-Foo-Bar': ModelWithString; + }; + path: { + /** + * bar in method + */ + BarParam: string; + /** + * foo in method + */ + foo_param: string; + }; +}; + +export type CallWithDescriptionsData = { + query?: { + /** + * Testing backticks in string: `backticks` and ```multiple backticks``` should work + */ + parameterWithBackticks?: unknown; + /** + * Testing multiline comments in string: First line + * Second line + * + * Fourth line + */ + parameterWithBreaks?: unknown; + /** + * Testing expression placeholders in string: ${expression} should work + */ + parameterWithExpressionPlaceholders?: unknown; + /** + * Testing quotes in string: 'single quote''' and "double quotes""" should work + */ + parameterWithQuotes?: unknown; + /** + * Testing reserved characters in string: * inline * and ** inline ** should work + */ + parameterWithReservedCharacters?: unknown; + /** + * Testing slashes in string: \backwards\\\ and /forwards/// should work + */ + parameterWithSlashes?: unknown; + }; +}; + +export type DeprecatedCallData = { + headers: { + /** + * This parameter is deprecated + * @deprecated + */ + parameter: DeprecatedModel | null; + }; +}; + +export type CallWithParametersData = { + /** + * This is the parameter that goes into the body + */ + body: { + [key: string]: unknown; + } | null; + headers: { + /** + * This is the parameter that goes into the header + */ + parameterHeader: string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + parameterPath: string | null; + }; + query: { + /** + * This is the parameter that goes into the query params + */ + cursor: string | null; + foo_all_of_enum: ModelWithNestedArrayEnumsDataFoo; + foo_ref_enum?: ModelWithNestedArrayEnumsDataFoo; + }; +}; + +export type CallWithWeirdParameterNamesData = { + /** + * This is the parameter that goes into the body + */ + body: ModelWithString | null; + headers: { + /** + * This is the parameter that goes into the request header + */ + 'parameter.header': string | null; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + /** + * This is the parameter that goes into the path + */ + 'parameter-path-2'?: string; + /** + * This is the parameter that goes into the path + */ + 'PARAMETER-PATH-3'?: string; + /** + * This is the parameter that goes into the path + */ + 'parameter.path.1'?: string; + }; + query: { + /** + * This is the parameter with a reserved keyword + */ + default?: string; + /** + * This is the parameter that goes into the request query params + */ + 'parameter-query': string | null; + }; +}; + +export type GetCallWithOptionalParamData = { + /** + * This is a required parameter + */ + body: ModelWithOneOfEnum; + query?: { + /** + * This is an optional parameter + */ + page?: number; + }; +}; + +export type PostCallWithOptionalParamData = { + /** + * This is an optional parameter + */ + body?: { + offset?: number | null; + }; + query: { + /** + * This is a required parameter + */ + parameter: Pageable; + }; +}; + +export type PostCallWithOptionalParamResponse = number | void; + +export type PostCallWithOptionalParamError = unknown; + +export type PostApiVbyApiVersionRequestBodyData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type PostApiVbyApiVersionFormDataData = { + /** + * A reusable request body + */ + body?: ModelWithString; + query?: { + /** + * This is a reusable parameter + */ + parameter?: string; + }; +}; + +export type CallWithDefaultParametersData = { + query?: { + /** + * This is a simple boolean with default value + */ + parameterBoolean?: boolean | null; + /** + * This is a simple enum with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model with default value + */ + parameterModel?: ModelWithString | null; + /** + * This is a simple number with default value + */ + parameterNumber?: number | null; + /** + * This is a simple string with default value + */ + parameterString?: string | null; + }; +}; + +export type CallWithDefaultOptionalParametersData = { + query?: { + /** + * This is a simple boolean that is optional with default value + */ + parameterBoolean?: boolean; + /** + * This is a simple enum that is optional with default value + */ + parameterEnum?: 'Success' | 'Warning' | 'Error'; + /** + * This is a simple model that is optional with default value + */ + parameterModel?: ModelWithString; + /** + * This is a simple number that is optional with default value + */ + parameterNumber?: number; + /** + * This is a simple string that is optional with default value + */ + parameterString?: string; + }; +}; + +export type CallToTestOrderOfParamsData = { + query: { + /** + * This is a optional string with default + */ + parameterOptionalStringWithDefault?: string; + /** + * This is a optional string with empty default + */ + parameterOptionalStringWithEmptyDefault?: string; + /** + * This is a optional string with no default + */ + parameterOptionalStringWithNoDefault?: string; + /** + * This is a string that can be null with default + */ + parameterStringNullableWithDefault?: string | null; + /** + * This is a string that can be null with no default + */ + parameterStringNullableWithNoDefault?: string | null; + /** + * This is a string with default + */ + parameterStringWithDefault: string; + /** + * This is a string with empty default + */ + parameterStringWithEmptyDefault: string; + /** + * This is a string with no default + */ + parameterStringWithNoDefault: string; + }; +}; + +export type CallWithNoContentResponseResponse = void; + +export type CallWithNoContentResponseError = unknown; + +export type CallWithResponseAndNoContentResponseResponse = number | void; + +export type CallWithResponseAndNoContentResponseError = unknown; + +export type DummyAResponse = _400; + +export type DummyAError = unknown; + +export type DummyBResponse = void; + +export type DummyBError = unknown; + +export type CallWithResponseResponse = _import; + +export type CallWithResponseError = unknown; + +export type CallWithDuplicateResponsesResponse = ModelWithBoolean & ModelWithInteger | ModelWithString; + +export type CallWithDuplicateResponsesError = ModelWithStringError | DictionaryWithArray | ModelWithBoolean; + +export type CallWithResponsesResponse = { + readonly '@namespace.string'?: string; + readonly '@namespace.integer'?: number; + readonly value?: Array; +} | ModelThatExtends | ModelThatExtendsExtends; + +export type CallWithResponsesError = ModelWithStringError; + +export type CollectionFormatData = { + query: { + /** + * This is an array parameter that is sent as csv format (comma-separated values) + */ + parameterArrayCSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as multi format (multiple parameter instances) + */ + parameterArrayMulti: Array<(string)> | null; + /** + * This is an array parameter that is sent as pipes format (pipe-separated values) + */ + parameterArrayPipes: Array<(string)> | null; + /** + * This is an array parameter that is sent as ssv format (space-separated values) + */ + parameterArraySSV: Array<(string)> | null; + /** + * This is an array parameter that is sent as tsv format (tab-separated values) + */ + parameterArrayTSV: Array<(string)> | null; + }; +}; + +export type TypesData = { + path?: { + /** + * This is a number parameter + */ + id?: number; + }; + query: { + /** + * This is an array parameter + */ + parameterArray: Array<(string)> | null; + /** + * This is a boolean parameter + */ + parameterBoolean: boolean | null; + /** + * This is a dictionary parameter + */ + parameterDictionary: { + [key: string]: unknown; + } | null; + /** + * This is an enum parameter + */ + parameterEnum: 'Success' | 'Warning' | 'Error' | null; + /** + * This is a number parameter + */ + parameterNumber: number; + /** + * This is an object parameter + */ + parameterObject: { + [key: string]: unknown; + } | null; + /** + * This is a string parameter + */ + parameterString: string | null; + }; +}; + +export type TypesResponse = number | string | boolean | { + [key: string]: unknown; +}; + +export type TypesError = unknown; + +export type UploadFileData = { + body: (Blob | File); + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string | null; + }; +}; + +export type UploadFileResponse = boolean; + +export type UploadFileError = unknown; + +export type FileResponseData = { + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: string; + }; +}; + +export type FileResponseResponse = (Blob | File); + +export type FileResponseError = unknown; + +export type ComplexTypesData = { + query: { + /** + * Parameter containing object + */ + parameterObject: { + first?: { + second?: { + third?: string; + }; + }; + }; + /** + * Parameter containing reference + */ + parameterReference: ModelWithString; + }; +}; + +export type ComplexTypesResponse = Array; + +export type ComplexTypesError = unknown; + +export type MultipartRequestData = { + body?: { + content?: (Blob | File); + data?: ModelWithString | null; + }; +}; + +export type MultipartResponseResponse = { + file?: (Blob | File); + metadata?: { + foo?: string; + bar?: string; + }; +}; + +export type MultipartResponseError = unknown; + +export type ComplexParamsData = { + body?: { + readonly key: string | null; + name: string | null; + enabled?: boolean; + readonly type: 'Monkey' | 'Horse' | 'Bird'; + listOfModels?: Array | null; + listOfStrings?: Array<(string)> | null; + parameters: ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary; + readonly user?: { + readonly id?: number; + readonly name?: string | null; + }; + }; + path: { + /** + * api-version should be required in standalone clients + */ + 'api-version': string; + id: number; + }; +}; + +export type ComplexParamsResponse = ModelWithString; + +export type ComplexParamsError = unknown; + +export type CallWithResultFromHeaderResponse = string; + +export type CallWithResultFromHeaderError = unknown; + +export type TestErrorCodeData = { + query: { + /** + * Status code to return + */ + status: number; + }; +}; + +export type TestErrorCodeResponse = unknown; + +export type TestErrorCodeError = unknown; + +export type NonAsciiæøåÆøÅöôêÊ字符串Data = { + query: { + /** + * Dummy input param + */ + nonAsciiParamæøåÆØÅöôêÊ: number; + }; +}; + +export type NonAsciiæøåÆøÅöôêÊ字符串Response = Array; + +export type NonAsciiæøåÆøÅöôêÊ字符串Error = unknown; + +export type PutWithFormUrlEncodedData = { + body: ArrayWithStrings; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap new file mode 100644 index 000000000..162231640 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/@tanstack/vue-query.gen.ts.snap @@ -0,0 +1,108 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import type { Options } from '@hey-api/client-fetch'; +import { queryOptions, type UseMutationOptions } from '@tanstack/vue-query'; +import type { ParentModelWithDatesError, ParentModelWithDatesResponse, ModelWithDatesError, ModelWithDatesResponse, ModelWithDatesArrayError, ModelWithDatesArrayResponse, ArrayOfDatesError, ArrayOfDatesResponse, DateError, DateResponse, MultipleResponsesError, MultipleResponsesResponse } from '../types.gen'; +import { parentModelWithDates, modelWithDates, modelWithDatesArray, arrayOfDates, date, multipleResponses } from '../services.gen'; + +type QueryKey = [ + { + infinite?: boolean; + params: Pick; + scope: string; + } +]; + +const createQueryKeyParams = (options?: TOptions): QueryKey[0]["params"] => { + const params: QueryKey[0]["params"] = {} as QueryKey[0]["params"]; + if (options?.body) { + params.body = options.body; + } + if (options?.headers) { + params.headers = options.headers; + } + if (options?.path) { + params.path = options.path; + } + if (options?.query) { + params.query = options.query; + } + return params; +}; + +export const parentModelWithDatesOptions = (options?: Options) => { return queryOptions({ + queryFn: async ({ queryKey }) => { + const { data } = await parentModelWithDates({ + ...options, + ...queryKey[0].params, + throwOnError: true + }); + return data; + }, + queryKey: [ + { + params: createQueryKeyParams(options), + scope: 'parentModelWithDates' + } + ] +}); }; + +export const parentModelWithDatesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await parentModelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const modelWithDatesArrayMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await modelWithDatesArray({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const arrayOfDatesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await arrayOfDates({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const dateMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await date({ + ...options, + throwOnError: true + }); + return data; + } +}; + +export const multipleResponsesMutation: UseMutationOptions = { + mutationFn: async (options) => { + const { data } = await multipleResponses({ + ...options, + throwOnError: true + }); + return data; + } +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/index.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/index.ts.snap new file mode 100644 index 000000000..e11f63ca0 --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/index.ts.snap @@ -0,0 +1,3 @@ +// This file is auto-generated by @hey-api/openapi-ts +export * from './services.gen'; +export * from './types.gen'; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/services.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/services.gen.ts.snap new file mode 100644 index 000000000..fcb0cc83f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/services.gen.ts.snap @@ -0,0 +1,39 @@ +// This file is auto-generated by @hey-api/openapi-ts + +import { createClient, createConfig, type Options } from '@hey-api/client-fetch'; +import { type ParentModelWithDatesError, type ParentModelWithDatesResponse, type ModelWithDatesError, type ModelWithDatesResponse, type ModelWithDatesArrayError, type ModelWithDatesArrayResponse, type ArrayOfDatesError, type ArrayOfDatesResponse, type DateError, type DateResponse, type MultipleResponsesError, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; + +export const client = createClient(createConfig()); + +export const parentModelWithDates = (options?: Options) => { return (options?.client ?? client).post({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ParentModelWithDatesResponseTransformer +}); }; + +export const modelWithDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates', + responseTransformer: ModelWithDatesResponseTransformer +}); }; + +export const modelWithDatesArray = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/model-with-dates-array', + responseTransformer: ModelWithDatesArrayResponseTransformer +}); }; + +export const arrayOfDates = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/array-of-dates' +}); }; + +export const date = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/date' +}); }; + +export const multipleResponses = (options?: Options) => { return (options?.client ?? client).put({ + ...options, + url: '/api/multiple-responses' +}); }; \ No newline at end of file diff --git a/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/types.gen.ts.snap b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/types.gen.ts.snap new file mode 100644 index 000000000..da954d95f --- /dev/null +++ b/packages/openapi-ts/test/__snapshots__/test/generated/v3-hey-api-client-fetch-plugin-tanstack-vue-query_transform/types.gen.ts.snap @@ -0,0 +1,114 @@ +// This file is auto-generated by @hey-api/openapi-ts + +/** + * This is a model that contains a some dates + */ +export type SimpleModel = { + id: number; + name: string; + readonly enabled: boolean; +}; + +/** + * This is a model that contains a some dates + */ +export type ModelWithDates = { + id: number; + name: string; + readonly enabled: boolean; + readonly modified: Date; + readonly expires?: Date; +}; + +/** + * This is a model that contains a some dates and arrays + */ +export type ParentModelWithDates = { + id: number; + readonly modified?: Date; + items?: Array; + item?: ModelWithDates; + simpleItems?: Array; + simpleItem?: SimpleModel; + dates?: Array<(Date)>; + strings?: Array<(string)>; +}; + +export type ParentModelWithDatesResponse = ParentModelWithDates | unknown; + +export type ParentModelWithDatesError = unknown; + +export type ModelWithDatesResponse = ModelWithDates; + +export type ModelWithDatesError = unknown; + +export type ModelWithDatesArrayResponse = Array; + +export type ModelWithDatesArrayError = unknown; + +export type ArrayOfDatesResponse = Array<(Date)>; + +export type ArrayOfDatesError = unknown; + +export type DateResponse = Date; + +export type DateError = unknown; + +export type MultipleResponsesResponse = Array | Array; + +export type MultipleResponsesError = unknown; + +export type ParentModelWithDatesResponseTransformer = (data: any) => Promise; + +export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; + +export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; + +export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (data?.expires) { + data.expires = new Date(data.expires); + } + return data; +}; + +export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { + if (data?.modified) { + data.modified = new Date(data.modified); + } + if (Array.isArray(data?.items)) { + data.items.forEach(ModelWithDatesModelResponseTransformer); + } + if (data?.item) { + ModelWithDatesModelResponseTransformer(data.item); + } + if (Array.isArray(data?.dates)) { + data.dates = data.dates.map(item => new Date(item)); + } + return data; +}; + +export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { + if (data) { + ParentModelWithDatesModelResponseTransformer(data); + } + return data; +}; + +export type ModelWithDatesResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { + ModelWithDatesModelResponseTransformer(data); + return data; +}; + +export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise; + +export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { + if (Array.isArray(data)) { + data.forEach(ModelWithDatesModelResponseTransformer); + } + return data; +}; \ No newline at end of file diff --git a/packages/openapi-ts/test/index.spec.ts b/packages/openapi-ts/test/index.spec.ts index dd9e0b8fd..86ffef8f3 100644 --- a/packages/openapi-ts/test/index.spec.ts +++ b/packages/openapi-ts/test/index.spec.ts @@ -145,6 +145,30 @@ describe('OpenAPI v3', () => { description: 'generate Axios client with TanStack React Query plugin', name: 'v3-hey-api-client-axios-plugin-tanstack-react-query', }, + { + config: createConfig({ + client: '@hey-api/client-axios', + plugins: ['@tanstack/solid-query'], + }), + description: 'generate Axios client with TanStack Solid Query plugin', + name: 'v3-hey-api-client-axios-plugin-tanstack-solid-query', + }, + { + config: createConfig({ + client: '@hey-api/client-axios', + plugins: ['@tanstack/svelte-query'], + }), + description: 'generate Axios client with TanStack Svelte Query plugin', + name: 'v3-hey-api-client-axios-plugin-tanstack-svelte-query', + }, + { + config: createConfig({ + client: '@hey-api/client-axios', + plugins: ['@tanstack/vue-query'], + }), + description: 'generate Axios client with TanStack Vue Query plugin', + name: 'v3-hey-api-client-axios-plugin-tanstack-vue-query', + }, { config: createConfig({ client: '@hey-api/client-fetch', @@ -180,6 +204,31 @@ describe('OpenAPI v3', () => { description: 'generate Fetch API client with TanStack React Query plugin', name: 'v3-hey-api-client-fetch-plugin-tanstack-react-query', }, + { + config: createConfig({ + client: '@hey-api/client-fetch', + plugins: ['@tanstack/solid-query'], + }), + description: 'generate Fetch API client with TanStack Solid Query plugin', + name: 'v3-hey-api-client-fetch-plugin-tanstack-solid-query', + }, + { + config: createConfig({ + client: '@hey-api/client-fetch', + plugins: ['@tanstack/svelte-query'], + }), + description: + 'generate Fetch API client with TanStack Svelte Query plugin', + name: 'v3-hey-api-client-fetch-plugin-tanstack-svelte-query', + }, + { + config: createConfig({ + client: '@hey-api/client-fetch', + plugins: ['@tanstack/vue-query'], + }), + description: 'generate Fetch API client with TanStack Vue Query plugin', + name: 'v3-hey-api-client-fetch-plugin-tanstack-vue-query', + }, { config: createConfig({ client: 'xhr', diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 8dc840977..5ccb368ef 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -301,6 +301,73 @@ importers: specifier: 5.3.3 version: 5.3.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + examples/openapi-ts-tanstack-svelte-query: + dependencies: + '@hey-api/client-fetch': + specifier: workspace:* + version: link:../../packages/client-fetch + '@tanstack/svelte-query': + specifier: 5.51.21 + version: 5.51.21(svelte@4.2.7) + devDependencies: + '@fontsource/fira-mono': + specifier: 5.0.0 + version: 5.0.0 + '@hey-api/openapi-ts': + specifier: workspace:* + version: link:../../packages/openapi-ts + '@neoconfetti/svelte': + specifier: 2.0.0 + version: 2.0.0 + '@sveltejs/adapter-auto': + specifier: 3.0.0 + version: 3.0.0(@sveltejs/kit@2.0.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1))) + '@sveltejs/kit': + specifier: 2.0.0 + version: 2.0.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + '@sveltejs/vite-plugin-svelte': + specifier: 3.0.0 + version: 3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + '@types/eslint': + specifier: 9.6.0 + version: 9.6.0 + eslint: + specifier: 9.0.0 + version: 9.0.0 + eslint-config-prettier: + specifier: 9.1.0 + version: 9.1.0(eslint@9.0.0) + eslint-plugin-svelte: + specifier: 2.36.0 + version: 2.36.0(eslint@9.0.0)(svelte@4.2.7)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)) + globals: + specifier: 15.0.0 + version: 15.0.0 + prettier: + specifier: 3.1.1 + version: 3.1.1 + prettier-plugin-svelte: + specifier: 3.1.2 + version: 3.1.2(prettier@3.1.1)(svelte@4.2.7) + svelte: + specifier: 4.2.7 + version: 4.2.7 + svelte-check: + specifier: 3.6.0 + version: 3.6.0(@babel/core@7.24.7)(less@4.2.0)(postcss-load-config@4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)))(postcss@8.4.39)(sass@1.71.1)(svelte@4.2.7) + typescript: + specifier: 5.5.3 + version: 5.5.3 + typescript-eslint: + specifier: 8.0.0 + version: 8.0.0(eslint@9.0.0)(typescript@5.5.3) + vite: + specifier: 5.0.3 + version: 5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + vitest: + specifier: 2.0.0 + version: 2.0.0(@types/node@20.14.10)(jsdom@24.1.0)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + examples/openapi-ts-tanstack-vue-query: dependencies: '@hey-api/client-fetch': @@ -345,7 +412,7 @@ importers: version: 4.0.0(vite@5.3.3(@types/node@20.14.5)(less@4.2.0)(sass@1.71.1)(terser@5.31.1))(vue@3.4.37(typescript@5.5.3)) '@vue/eslint-config-prettier': specifier: 9.0.0 - version: 9.0.0(@types/eslint@8.56.10)(eslint@9.6.0)(prettier@3.3.2) + version: 9.0.0(@types/eslint@9.6.0)(eslint@9.6.0)(prettier@3.3.2) '@vue/eslint-config-typescript': specifier: 13.0.0 version: 13.0.0(eslint-plugin-vue@9.27.0(eslint@9.6.0))(eslint@9.6.0)(typescript@5.5.3) @@ -459,6 +526,12 @@ importers: '@tanstack/react-query': specifier: 5.51.23 version: 5.51.23(react@18.3.1) + '@tanstack/solid-query': + specifier: 5.51.21 + version: 5.51.21(solid-js@1.8.20) + '@tanstack/svelte-query': + specifier: 5.51.21 + version: 5.51.21(svelte@4.2.7) '@tanstack/vue-query': specifier: 5.51.21 version: 5.51.21(vue@3.4.37(typescript@5.5.3)) @@ -1945,6 +2018,10 @@ packages: resolution: {integrity: sha512-4Bfj15dVJdoy3RfZmmo86RK1Fwzn6SstsvK9JS+BaVKqC6QQQQyXekNaC+g+LKNgkQ+2VhGAzm6hO40AhMR3zQ==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/js@9.0.0': + resolution: {integrity: sha512-RThY/MnKrhubF6+s1JflwUjPEsnCEmYCWwqa/aRISKWNXGZ9epUwft4bUMM35SdKF9xvBrLydAM1RDHd1Z//ZQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@eslint/js@9.6.0': resolution: {integrity: sha512-D9B0/3vNg44ZeWbYMpBoXqNP4j6eQD5vNwIlGAuFRRzK/WtT/jvDQW3Bi9kkf3PMDMlM7Yi+73VLUsn5bJcl8A==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -1968,10 +2045,22 @@ packages: '@floating-ui/utils@0.2.2': resolution: {integrity: sha512-J4yDIIthosAsRZ5CPYP/jQvUAQtlZTTD/4suA08/FEnlxqW3sKS9iAhgsa9VYLZ6vDHn/ixJgIqRQPotoBjxIw==} + '@fontsource/fira-mono@5.0.0': + resolution: {integrity: sha512-IsinH/oLYJyv/sQv7SbKmjoAXZsSjm6Q1Tz5GBBXCXi3Jg9MzXmKvWm9bSLC8lFI6CDsi8GkH/DAgZ98t8bhTQ==} + + '@humanwhocodes/config-array@0.12.3': + resolution: {integrity: sha512-jsNnTBlMWuTpDkeE3on7+dWJi0D6fdDfeANj/w7MpS8ztROCoLvIO2nG0CcFj+E4k8j4QrSTh4Oryi3i2G669g==} + engines: {node: '>=10.10.0'} + deprecated: Use @eslint/config-array instead + '@humanwhocodes/module-importer@1.0.1': resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} engines: {node: '>=12.22'} + '@humanwhocodes/object-schema@2.0.3': + resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} + deprecated: Use @eslint/object-schema instead + '@humanwhocodes/retry@0.3.0': resolution: {integrity: sha512-d2CGZR2o7fS6sWB7DG/3a95bGKQyHMACZ5aW8qGkkqQpUoZV6C0X7Pc7l4ZNMZkfNBf4VWNe9E1jRsf0G146Ew==} engines: {node: '>=18.18'} @@ -2032,6 +2121,9 @@ packages: '@manypkg/get-packages@1.1.3': resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} + '@neoconfetti/svelte@2.0.0': + resolution: {integrity: sha512-n/Uu7/XmHc8w0uBci0QWBjgbRzLhfWsH8yPJ5pMaseIvzSwabXvB30nb3JjzEYNBp9uGt4eCeY7LUmxAjnJV8A==} + '@ngtools/webpack@17.3.7': resolution: {integrity: sha512-kQNS68jsPQlaWAnKcVeFKNHp6K90uQANvq+9oXb/i+JnYWzuBsHzn2r8bVdMmvjd1HdBRiGtg767XRk3u+jgRw==} engines: {node: ^18.13.0 || >=20.9.0, npm: ^6.11.0 || ^7.5.6 || >=8.0.0, yarn: '>= 1.13.0'} @@ -2878,6 +2970,35 @@ packages: '@stackblitz/sdk@1.11.0': resolution: {integrity: sha512-DFQGANNkEZRzFk1/rDP6TcFdM82ycHE+zfl9C/M/jXlH68jiqHWHFMQURLELoD8koxvu/eW5uhg94NSAZlYrUQ==} + '@sveltejs/adapter-auto@3.0.0': + resolution: {integrity: sha512-UNWSs/rOReBRfI/xFwSO2WYF1a7PT74SrWOHJmSNLY3Lq+zbH0uuvnlP+TmrTUBvOTkou3WJDjL6lK3n6aOUgQ==} + peerDependencies: + '@sveltejs/kit': ^2.0.0 + + '@sveltejs/kit@2.0.0': + resolution: {integrity: sha512-/GFxvit+q7PztRbgGTFXhVB6jvb0fZSeWuz5f4siQ2r/5BVhxYh7++Bw3/ZUjiOuyoZFiNBmOPcRNQbkzEce0g==} + engines: {node: '>=18.13'} + hasBin: true + peerDependencies: + '@sveltejs/vite-plugin-svelte': ^3.0.0 + svelte: ^4.0.0 || ^5.0.0-next.0 + vite: ^5.0.3 + + '@sveltejs/vite-plugin-svelte-inspector@2.1.0': + resolution: {integrity: sha512-9QX28IymvBlSCqsCll5t0kQVxipsfhFFL+L2t3nTWfXnddYwxBuAEtTtlaVQpRz9c37BhJjltSeY4AJSC03SSg==} + engines: {node: ^18.0.0 || >=20} + peerDependencies: + '@sveltejs/vite-plugin-svelte': ^3.0.0 + svelte: ^4.0.0 || ^5.0.0-next.0 + vite: ^5.0.0 + + '@sveltejs/vite-plugin-svelte@3.0.0': + resolution: {integrity: sha512-Th0nupxk8hl5Rcg9jm+1xWylwco4bSUAvutWxM4W4bjOAollpXLmrYqSSnYo9pPbZOO6ZGRm6sSqYa/v1d/Saw==} + engines: {node: ^18.0.0 || >=20} + peerDependencies: + svelte: ^4.0.0 || ^5.0.0-next.0 + vite: ^5.0.0 + '@tanstack/match-sorter-utils@8.19.4': resolution: {integrity: sha512-Wo1iKt2b9OT7d+YGhvEPD3DXvPv2etTusIMhMUoG7fbhmxcXCtIjJDEygy91Y2JFlwGyjqiBPRozme7UD8hoqg==} engines: {node: '>=12'} @@ -2899,6 +3020,16 @@ packages: peerDependencies: react: ^18.0.0 + '@tanstack/solid-query@5.51.21': + resolution: {integrity: sha512-ZwiTMpownN5qwEZE7UB7ccfGkbzSECkZOv/P1+SQ+dKchNtkF9sA0Zz8IVnr6lgqumkCwS8M65ciBdzI0JfTAQ==} + peerDependencies: + solid-js: ^1.6.0 + + '@tanstack/svelte-query@5.51.21': + resolution: {integrity: sha512-NaayXSdq6LDxcbtrdo45dliFuXz7tHfDSijDyyGQv5R7bqIaK1OJ2io+mXF75ufIj1WReR1tNb9qGBOjo8/Jqw==} + peerDependencies: + svelte: ^3.54.0 || ^4.0.0 || ^5.0.0-next.0 + '@tanstack/vue-query-devtools@5.51.21': resolution: {integrity: sha512-PYZFbTxWiYjfdppZL1mLL9mqsJw4ZOqUpFYTOvjDNj+pJ8SEQJL+2mg3IbOJ0xkkv72W9xOgQYIWHUe+rI9ANA==} peerDependencies: @@ -2964,14 +3095,17 @@ packages: '@types/connect@3.4.38': resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==} + '@types/cookie@0.6.0': + resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==} + '@types/cross-spawn@6.0.6': resolution: {integrity: sha512-fXRhhUkG4H3TQk5dBhQ7m/JDdSNHKwR2BBia62lhwEIq9xGiQKLxd6LymNhn47SjXhsUEPmxi+PKw2OkW4LLjA==} '@types/eslint-scope@3.7.7': resolution: {integrity: sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==} - '@types/eslint@8.56.10': - resolution: {integrity: sha512-Shavhk87gCtY2fhXDctcfS3e6FdxWkCx1iUZ9eEUbh7rTqlZT0/IzOkCOVt0fCjcFuZ9FPYfuezTBImfHCDBGQ==} + '@types/eslint@9.6.0': + resolution: {integrity: sha512-gi6WQJ7cHRgZxtkQEoyHMppPjq9Kxo5Tjn2prSKDSmZrCz8TZ3jSRCeTJm+WoM+oB0WG37bRqLzaaU3q7JypGg==} '@types/estree@1.0.5': resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==} @@ -3024,6 +3158,9 @@ packages: '@types/prop-types@15.7.12': resolution: {integrity: sha512-5zvhXYtRNRluoE/jAp4GVsSduVUzNWKkOZrCDBWYtE7biZywwdC2AcEzg+cSMLFRfVgeAFqpfNabiPjxFddV1Q==} + '@types/pug@2.0.10': + resolution: {integrity: sha512-Sk/uYFOBAB7mb74XcpizmH0KOR2Pv3D2Hmrh1Dmy5BmK3MpdSa5kqZcg6EKBdklU0bFXX9gCfzvpnyUehrPIuA==} + '@types/qs@6.9.15': resolution: {integrity: sha512-uXHQKES6DQKKCLh441Xv/dwxOq1TVS3JPUMlEqoEglvlhR6Mxnlew/Xq/LRVHpLyk7iK3zODe1qYHIMltO7XGg==} @@ -3083,6 +3220,17 @@ packages: typescript: optional: true + '@typescript-eslint/eslint-plugin@8.0.0': + resolution: {integrity: sha512-STIZdwEQRXAHvNUS6ILDf5z3u95Gc8jzywunxSNqX00OooIemaaNIA0vEgynJlycL5AjabYLLrIyHd4iazyvtg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + '@typescript-eslint/parser': ^8.0.0 || ^8.0.0-alpha.0 + eslint: ^8.57.0 || ^9.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + '@typescript-eslint/experimental-utils@5.62.0': resolution: {integrity: sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3099,6 +3247,16 @@ packages: typescript: optional: true + '@typescript-eslint/parser@8.0.0': + resolution: {integrity: sha512-pS1hdZ+vnrpDIxuFXYQpLTILglTjSYJ9MbetZctrUawogUsPdz31DIIRZ9+rab0LhYNTsk88w4fIzVheiTbWOQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + '@typescript-eslint/scope-manager@5.62.0': resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3107,6 +3265,10 @@ packages: resolution: {integrity: sha512-Q/1yrF/XbxOTvttNVPihxh1b9fxamjEoz2Os/Pe38OHwxC24CyCqXxGTOdpb4lt6HYtqw9HetA/Rf6gDGaMPlw==} engines: {node: ^18.18.0 || >=20.0.0} + '@typescript-eslint/scope-manager@8.0.0': + resolution: {integrity: sha512-V0aa9Csx/ZWWv2IPgTfY7T4agYwJyILESu/PVqFtTFz9RIS823mAze+NbnBI8xiwdX3iqeQbcTYlvB04G9wyQw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/type-utils@7.15.0': resolution: {integrity: sha512-SkgriaeV6PDvpA6253PDVep0qCqgbO1IOBiycjnXsszNTVQe5flN5wR5jiczoEoDEnAqYFSFFc9al9BSGVltkg==} engines: {node: ^18.18.0 || >=20.0.0} @@ -3117,6 +3279,15 @@ packages: typescript: optional: true + '@typescript-eslint/type-utils@8.0.0': + resolution: {integrity: sha512-mJAFP2mZLTBwAn5WI4PMakpywfWFH5nQZezUQdSKV23Pqo6o9iShQg1hP2+0hJJXP2LnZkWPphdIq4juYYwCeg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + '@typescript-eslint/types@5.62.0': resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3125,6 +3296,10 @@ packages: resolution: {integrity: sha512-aV1+B1+ySXbQH0pLK0rx66I3IkiZNidYobyfn0WFsdGhSXw+P3YOqeTq5GED458SfB24tg+ux3S+9g118hjlTw==} engines: {node: ^18.18.0 || >=20.0.0} + '@typescript-eslint/types@8.0.0': + resolution: {integrity: sha512-wgdSGs9BTMWQ7ooeHtu5quddKKs5Z5dS+fHLbrQI+ID0XWJLODGMHRfhwImiHoeO2S5Wir2yXuadJN6/l4JRxw==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@typescript-eslint/typescript-estree@5.62.0': resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3143,6 +3318,15 @@ packages: typescript: optional: true + '@typescript-eslint/typescript-estree@8.0.0': + resolution: {integrity: sha512-5b97WpKMX+Y43YKi4zVcCVLtK5F98dFls3Oxui8LbnmRsseKenbbDinmvxrWegKDMmlkIq/XHuyy0UGLtpCDKg==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + '@typescript-eslint/utils@5.62.0': resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3155,6 +3339,12 @@ packages: peerDependencies: eslint: ^8.56.0 + '@typescript-eslint/utils@8.0.0': + resolution: {integrity: sha512-k/oS/A/3QeGLRvOWCg6/9rATJL5rec7/5s1YmdS0ZU6LHveJyGFwBvLhSRBv6i9xaj7etmosp+l+ViN1I9Aj/Q==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + eslint: ^8.57.0 || ^9.0.0 + '@typescript-eslint/visitor-keys@5.62.0': resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} @@ -3163,6 +3353,10 @@ packages: resolution: {integrity: sha512-Hqgy/ETgpt2L5xueA/zHHIl4fJI2O4XUE9l4+OIfbJIRSnTJb/QscncdqqZzofQegIJugRIF57OJea1khw2SDw==} engines: {node: ^18.18.0 || >=20.0.0} + '@typescript-eslint/visitor-keys@8.0.0': + resolution: {integrity: sha512-oN0K4nkHuOyF3PVMyETbpP5zp6wfyOvm7tWhTMfoqxSSsPmJIh6JNASuZDlODE8eE+0EB9uar+6+vxr9DBTYOA==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + '@vitejs/plugin-basic-ssl@1.1.0': resolution: {integrity: sha512-wO4Dk/rm8u7RNhOf95ZzcEmC9rYOncYgvq4z3duaJrCgjN8BxAnDVyndanfcJZ0O6XZzHz6Q0hTimxTg8Y9g/A==} engines: {node: '>=14.6.0'} @@ -3197,18 +3391,33 @@ packages: '@vitest/expect@1.6.0': resolution: {integrity: sha512-ixEvFVQjycy/oNgHjqsL6AZCDduC+tflRluaHIzKIsdbzkLn2U/iBnVeJwB6HsIjQBdfMR8Z0tRxKUsvFJEeWQ==} + '@vitest/expect@2.0.0': + resolution: {integrity: sha512-5BSfZ0+dAVmC6uPF7s+TcKx0i7oyYHb1WQQL5gg6G2c+Qkaa5BNrdRM74sxDfUIZUgYCr6bfCqmJp+X5bfcNxQ==} + '@vitest/runner@1.6.0': resolution: {integrity: sha512-P4xgwPjwesuBiHisAVz/LSSZtDjOTPYZVmNAnpHHSR6ONrf8eCJOFRvUwdHn30F5M1fxhqtl7QZQUk2dprIXAg==} + '@vitest/runner@2.0.0': + resolution: {integrity: sha512-OovFmlkfRmdhevbWImBUtn9IEM+CKac8O+m9p6W9jTATGVBnDJQ6/jb1gpHyWxsu0ALi5f+TLi+Uyst7AAimMw==} + '@vitest/snapshot@1.6.0': resolution: {integrity: sha512-+Hx43f8Chus+DCmygqqfetcAZrDJwvTj0ymqjQq4CvmpKFSTVteEOBzCusu1x2tt4OJcvBflyHUE0DZSLgEMtQ==} + '@vitest/snapshot@2.0.0': + resolution: {integrity: sha512-B520cSAQwtWgocPpARadnNLslHCxFs5tf7SG2TT96qz+SZgsXqcB1xI3w3/S9kUzdqykEKrMLvW+sIIpMcuUdw==} + '@vitest/spy@1.6.0': resolution: {integrity: sha512-leUTap6B/cqi/bQkXUu6bQV5TZPx7pmMBKBQiI0rJA8c3pB56ZsaTbREnF7CJfmvAS4V2cXIBAh/3rVwrrCYgw==} + '@vitest/spy@2.0.0': + resolution: {integrity: sha512-0g7ho4wBK09wq8iNZFtUcQZcUcbPmbLWFotL0GXel0fvk5yPi4nTEKpIvZ+wA5eRyqPUCIfIUl10AWzLr67cmA==} + '@vitest/utils@1.6.0': resolution: {integrity: sha512-21cPiuGMoMZwiOHa2i4LXkMkMkCGzA+MVFV70jRwHo95dL4x/ts5GZhML1QWuy7yfp3WzK3lRvZi3JnXTYqrBw==} + '@vitest/utils@2.0.0': + resolution: {integrity: sha512-t0jbx8VugWEP6A29NbyfQKVU68Vo6oUw0iX3a8BwO3nrZuivfHcFO4Y5UsqXlplX+83P9UaqEvC2YQhspC0JSA==} + '@volar/language-core@2.4.0-alpha.18': resolution: {integrity: sha512-JAYeJvYQQROmVRtSBIczaPjP3DX4QW1fOqW1Ebs0d3Y3EwSNRglz03dSv0Dm61dzd0Yx3WgTW3hndDnTQqgmyg==} @@ -3562,6 +3771,9 @@ packages: resolution: {integrity: sha512-y+CcFFwelSXpLZk/7fMB2mUbGtX9lKycf1MWJ7CaTIERyitVlyQx6C+sxcROU2BAJ24OiZyK+8wj2i8AlBoS3A==} engines: {node: '>=10'} + aria-query@5.3.0: + resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} + array-flatten@1.1.1: resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} @@ -3572,6 +3784,10 @@ packages: assertion-error@1.1.0: resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} + assertion-error@2.0.1: + resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} + engines: {node: '>=12'} + ast-types@0.13.4: resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==} engines: {node: '>=4'} @@ -3596,6 +3812,10 @@ packages: axios@1.7.3: resolution: {integrity: sha512-Ar7ND9pU99eJ9GpoGQKhKf58GpUOgnzuaB7ueNQ5BMi0p+LZ5oaEnfF999fAArcTIBwXTCHAmGcHOZJaWPq9Nw==} + axobject-query@3.2.4: + resolution: {integrity: sha512-aPTElBrbifBU1krmZxGZOlBkslORe7Ll7+BDnI50Wy4LgOt69luMgevkDfTq1O/ZgprooPCtWpjCwKSZw/iZ4A==} + engines: {node: '>= 0.4'} + b4a@1.6.6: resolution: {integrity: sha512-5Tk1HLk6b6ctmjIkAcU/Ujv/1WqiDl0F0JdRCR80VsOcUlHcu7pWeWRlOqQLHfDEsVx9YH/aif5AG4ehoCtTmg==} @@ -3698,6 +3918,10 @@ packages: buffer-crc32@0.2.13: resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==} + buffer-crc32@1.0.0: + resolution: {integrity: sha512-Db1SbgBS/fg/392AblrMJk97KggmvYhr4pB5ZIMTWtaivCPMWLkmb7m21cJvpvgK+J3nsU2CmmixNBZx4vFj/w==} + engines: {node: '>=8.0.0'} + buffer-from@1.1.2: resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} @@ -3763,6 +3987,10 @@ packages: resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} engines: {node: '>=4'} + chai@5.1.1: + resolution: {integrity: sha512-pT1ZgP8rPNqUgieVaEY+ryQr6Q4HXNg8Ei9UnLUrjN4IA7dvQC5JB+/kxVcPNDHyBcc/26CXPkbNzq3qwrOEKA==} + engines: {node: '>=12'} + chalk@2.4.2: resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} engines: {node: '>=4'} @@ -3781,6 +4009,10 @@ packages: check-error@1.0.3: resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} + check-error@2.1.1: + resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==} + engines: {node: '>= 16'} + chokidar@3.6.0: resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} engines: {node: '>= 8.10.0'} @@ -3844,6 +4076,9 @@ packages: resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} engines: {node: '>=0.8'} + code-red@1.0.4: + resolution: {integrity: sha512-7qJWqItLA8/VPVlKJlFXU+NBlo/qyfs39aJcuMT/2ere32ZqvF5OSxgdM5xOfJJ7O429gg2HM47y8v9P+9wrNw==} + color-convert@1.9.3: resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} @@ -3990,6 +4225,10 @@ packages: css-select@5.1.0: resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==} + css-tree@2.3.1: + resolution: {integrity: sha512-6Fv1DV/TYw//QF5IzQdqsNDjx/wc8TrMBZsqjL9eW01tWb7R7k/mq+/VXfJCl7SoD5emsJop9cOByJZfs8hYIw==} + engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0} + css-what@6.1.0: resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==} engines: {node: '>= 6'} @@ -4057,6 +4296,10 @@ packages: resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==} engines: {node: '>=6'} + deep-eql@5.0.2: + resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} + engines: {node: '>=6'} + deep-is@0.1.4: resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} @@ -4110,6 +4353,10 @@ packages: resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} engines: {node: '>= 0.8'} + dequal@2.0.3: + resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} + engines: {node: '>=6'} + destr@2.0.3: resolution: {integrity: sha512-2N3BOUU4gYMpTP24s5rF5iP7BDr7uNTCs4ozw3kf/eKfvWSIu93GEBi5m427YoyJoeOzQ5smuu4nNAPGb8idSQ==} @@ -4127,6 +4374,9 @@ packages: detect-node@2.1.0: resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==} + devalue@4.3.3: + resolution: {integrity: sha512-UH8EL6H2ifcY8TbD2QsxwCC/pr5xSwPvv85LrLXVihmHVC3T3YqTCIwnR5ak0yO1KYqlxrPVOA/JVZJYPy2ATg==} + devtools-protocol@0.0.1299070: resolution: {integrity: sha512-+qtL3eX50qsJ7c+qVyagqi7AWMoQCBGNfoyJZMwm/NSXVqLYbuitrWEEIzxfUmTNy7//Xe8yhMmQ+elj3uAqSg==} @@ -4254,6 +4504,9 @@ packages: es-module-lexer@1.5.3: resolution: {integrity: sha512-i1gCgmR9dCl6Vil6UKPI/trA69s08g/syhiDK9TG0Nf1RJjjFI+AzoWW7sPufzkgYAn861skuCwJa0pIIHYxvg==} + es6-promise@3.3.1: + resolution: {integrity: sha512-SOp9Phqvqn7jtEUxPWdWfWoLmyt2VaJ6MpvP9Comy1MceMXqE6bxvaTu4iaxpYYPzhny28Lc+M87/c2cPK6lDg==} + esbuild-wasm@0.20.1: resolution: {integrity: sha512-6v/WJubRsjxBbQdz6izgvx7LsVFvVaGmSdwrFHmEzoVgfXL89hkKPoQHsnVI2ngOkcBUQT9kmAM1hVL1k/Av4A==} engines: {node: '>=12'} @@ -4294,6 +4547,12 @@ packages: engines: {node: '>=6.0'} hasBin: true + eslint-compat-utils@0.5.1: + resolution: {integrity: sha512-3z3vFexKIEnjHE3zCMRo6fn/e44U7T1khUjg+Hp0ZQMCigh28rALD0nPFBcGZuiLC5rLZa2ubQHDRln09JfU2Q==} + engines: {node: '>=12'} + peerDependencies: + eslint: '>=6.0.0' + eslint-config-prettier@9.1.0: resolution: {integrity: sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==} hasBin: true @@ -4334,6 +4593,16 @@ packages: resolution: {integrity: sha512-DNPHFGCA0/hZIsfODbeLZqaGY/+q3vgtshF85r+YWDNCQ2apd9PNs/zL6ttKm0nD1IFwvxyg3YOTI7FHl4unrw==} engines: {node: '>=0.10.0'} + eslint-plugin-svelte@2.36.0: + resolution: {integrity: sha512-D30hSj13Y8YEn7yGXos7EYp0lpEb3Z2V/M+6a3MZ13KGVhaefdW2A9j8IBIcW4YR+j6fo901USzLeXQz/XbWeQ==} + engines: {node: ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^7.0.0 || ^8.0.0-0 || ^9.0.0-0 + svelte: ^3.37.0 || ^4.0.0 || ^5.0.0-next.95 + peerDependenciesMeta: + svelte: + optional: true + eslint-plugin-typescript-sort-keys@3.2.0: resolution: {integrity: sha512-GutszvriaVtwmn7pQjuj9/9o0iXhD7XZs0/424+zsozdRr/fdg5e8206t478Vnqnqi1GjuxcAolj1kf74KnhPA==} engines: {node: '>= 16'} @@ -4378,11 +4647,19 @@ packages: resolution: {integrity: sha512-OtIRv/2GyiF6o/d8K7MYKKbXrOUBIK6SfkIRM4Z0dY3w+LiQ0vy3F57m0Z71bjbyeiWFiHJ8brqnmE6H6/jEuw==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + eslint@9.0.0: + resolution: {integrity: sha512-IMryZ5SudxzQvuod6rUdIUz29qFItWx281VhtFVc2Psy/ZhlCeD/5DT6lBIJ4H3G+iamGJoTln1v+QSuPw0p7Q==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + hasBin: true + eslint@9.6.0: resolution: {integrity: sha512-ElQkdLMEEqQNM9Njff+2Y4q2afHk7JpkPvrd7Xh7xefwgQynqPxwf55J7di9+MEibWUGdNjFF9ITG9Pck5M84w==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} hasBin: true + esm-env@1.0.0: + resolution: {integrity: sha512-Cf6VksWPsTuW01vU9Mk/3vRue91Zevka5SjyNf3nEpokFRuqt/KjUQoGAwq9qMmhpLTHmXzSIrFRw8zxWzmFBA==} + espree@10.1.0: resolution: {integrity: sha512-M1M6CpiE6ffoigIOWYO9UDP8TMUw9kqb21tf+08IgDYjCsOvCuDt4jQcZmoYxx+w7zlKw9/N0KXfto+I8/FrXA==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -4694,10 +4971,17 @@ packages: resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==} engines: {node: '>=18'} + globals@15.0.0: + resolution: {integrity: sha512-m/C/yR4mjO6pXDTm9/R/SpYTAIyaUB4EOzcaaMEl7mds7Mshct9GfejiJNQGjHHbdMPey13Kpu4TMbYi9ex1pw==} + engines: {node: '>=18'} + globals@15.8.0: resolution: {integrity: sha512-VZAJ4cewHTExBWDHR6yptdIBlx9YSSZuwojj9Nt5mBRXQzrKakDsVKQ1J63sklLvzAJm0X5+RpO4i3Y2hcOnFw==} engines: {node: '>=18'} + globalyzer@0.1.0: + resolution: {integrity: sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==} + globby@11.1.0: resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} engines: {node: '>=10'} @@ -4706,6 +4990,9 @@ packages: resolution: {integrity: sha512-Y1zNGV+pzQdh7H39l9zgB4PJqjRNqydvdYCDG4HFXM4XuvSaQQlEc91IU1yALL8gUTDomgBAfz3XJdmUS+oo0w==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + globrex@0.1.2: + resolution: {integrity: sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==} + gopd@1.0.1: resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} @@ -4868,6 +5155,9 @@ packages: resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} engines: {node: '>=6'} + import-meta-resolve@4.1.0: + resolution: {integrity: sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==} + imurmurhash@0.1.4: resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} engines: {node: '>=0.8.19'} @@ -4994,6 +5284,9 @@ packages: is-reference@1.2.1: resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==} + is-reference@3.0.2: + resolution: {integrity: sha512-v3rht/LgVcsdZa3O2Nqs+NMowLOxeOm7Ay9+/ARQ2F+qEoANRcqrjAZKGN0v8ymUetZGgkp26LTnGT7H0Qo9Pg==} + is-stream@2.0.1: resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} engines: {node: '>=8'} @@ -5169,10 +5462,17 @@ packages: resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} engines: {node: '>=0.10.0'} + kleur@4.1.5: + resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==} + engines: {node: '>=6'} + klona@2.0.6: resolution: {integrity: sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==} engines: {node: '>= 8'} + known-css-properties@0.30.0: + resolution: {integrity: sha512-VSWXYUnsPu9+WYKkfmJyLKtIvaRJi1kXUqVmBACORXZQxT5oZDsoZ2vQP+bQFDnWtpI/4eq3MLoRMjI2fnLzTQ==} + kolorist@1.8.0: resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==} @@ -5243,6 +5543,9 @@ packages: resolution: {integrity: sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==} engines: {node: '>=14'} + locate-character@3.0.0: + resolution: {integrity: sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==} + locate-path@5.0.0: resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} engines: {node: '>=8'} @@ -5282,6 +5585,9 @@ packages: loupe@2.3.7: resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} + loupe@3.1.1: + resolution: {integrity: sha512-edNu/8D5MKVfGVFRhFf8aAxiTM6Wumfz5XsaatSxlD3w4R1d/WEKUTydCdPGbl9K7QG/Ca3GnDV2sIKIpXRQcw==} + lru-cache@10.4.0: resolution: {integrity: sha512-bfJaPTuEiTYBu+ulDaeQ0F+uLmlfFkMgXj4cbwfuMSjgObGMzb55FMMbDvbRU0fAHZ4sLGkz2mKwcMg8Dvm8Ww==} engines: {node: '>=18'} @@ -5328,6 +5634,9 @@ packages: mark.js@8.11.1: resolution: {integrity: sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==} + mdn-data@2.0.30: + resolution: {integrity: sha512-GaqWWShW4kv/G9IEucWScBx9G1/vsFZZJUO+tD26M8J8z3Kw5RDQjaoZe03YAClgeS/SWPOcb4nkFBTEi5DUEA==} + media-typer@0.3.0: resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} engines: {node: '>= 0.6'} @@ -5379,6 +5688,10 @@ packages: resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==} engines: {node: '>=12'} + min-indent@1.0.1: + resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} + engines: {node: '>=4'} + mini-css-extract-plugin@2.8.1: resolution: {integrity: sha512-/1HDlyFRxWIZPI1ZpgqlZ8jMw/1Dp/dl3P0L1jtZ+zVcHqwPhGwaJwKL00WVgfnBy6PWCde9W65or7IIETImuA==} engines: {node: '>= 12.13.0'} @@ -5447,6 +5760,10 @@ packages: mitt@3.0.1: resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==} + mkdirp@0.5.6: + resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} + hasBin: true + mkdirp@1.0.4: resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} engines: {node: '>=10'} @@ -5459,6 +5776,10 @@ packages: resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==} engines: {node: '>=4'} + mrmime@1.0.1: + resolution: {integrity: sha512-hzzEagAgDyoU1Q6yg5uI+AorQgdvMCur3FcKf7NhMKWsaYg+RnbTyHRa/9IlLF9rf455MOCtcqqrQQ83pPP7Uw==} + engines: {node: '>=10'} + mrmime@2.0.0: resolution: {integrity: sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==} engines: {node: '>=10'} @@ -5817,12 +6138,19 @@ packages: pathval@1.1.1: resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} + pathval@2.0.0: + resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==} + engines: {node: '>= 14.16'} + pend@1.2.0: resolution: {integrity: sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==} perfect-debounce@1.0.0: resolution: {integrity: sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==} + periscopic@3.1.0: + resolution: {integrity: sha512-vKiQ8RRtkl9P+r/+oefh25C3fhybptkHKCZSPlcXiJux2tJF55GnEj3BVn4A5gKfq9NWWXXrxkHBwVPUfH0opw==} + picocolors@1.0.1: resolution: {integrity: sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew==} @@ -5889,6 +6217,18 @@ packages: peerDependencies: postcss: ^8.4.21 + postcss-load-config@3.1.4: + resolution: {integrity: sha512-6DiM4E7v4coTE4uzA8U//WhtPwyhiim3eyjEMFCnUpzbrkK9wJHgKDT2mR+HbtSrd/NubVaYTOpSpjUl8NQeRg==} + engines: {node: '>= 10'} + peerDependencies: + postcss: '>=8.0.9' + ts-node: '>=9.0.0' + peerDependenciesMeta: + postcss: + optional: true + ts-node: + optional: true + postcss-load-config@4.0.2: resolution: {integrity: sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==} engines: {node: '>= 14'} @@ -5947,6 +6287,18 @@ packages: peerDependencies: postcss: ^8.2.14 + postcss-safe-parser@6.0.0: + resolution: {integrity: sha512-FARHN8pwH+WiS2OPCxJI8FuRJpTVnn6ZNFiqAM2aeW2LwTHWWmWgIyKC6cUo0L8aeKiF/14MNvnpls6R2PBeMQ==} + engines: {node: '>=12.0'} + peerDependencies: + postcss: ^8.3.3 + + postcss-scss@4.0.9: + resolution: {integrity: sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A==} + engines: {node: '>=12.0'} + peerDependencies: + postcss: ^8.4.29 + postcss-selector-parser@6.1.0: resolution: {integrity: sha512-UMz42UD0UY0EApS0ZL9o1XnLhSTtvvvLe5Dc2H2O56fvRZi+KulDyf5ctDhhtYJBGKStV2FL1fy6253cmLgqVQ==} engines: {node: '>=4'} @@ -5981,11 +6333,22 @@ packages: resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} engines: {node: '>=6.0.0'} + prettier-plugin-svelte@3.1.2: + resolution: {integrity: sha512-7xfMZtwgAWHMT0iZc8jN4o65zgbAQ3+O32V6W7pXrqNvKnHnkoyQCGCbKeUyXKZLbYE0YhFRnamfxfkEGxm8qA==} + peerDependencies: + prettier: ^3.0.0 + svelte: ^3.2.0 || ^4.0.0-next.0 || ^5.0.0-next.0 + prettier@2.8.8: resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} engines: {node: '>=10.13.0'} hasBin: true + prettier@3.1.1: + resolution: {integrity: sha512-22UbSzg8luF4UuZtzgiUOfcGM8s4tjBv6dJRT7j275NXsy2jb4aJa4NNveul5x4eqlF1wuhuR2RElK71RvmVaw==} + engines: {node: '>=14'} + hasBin: true + prettier@3.3.2: resolution: {integrity: sha512-rAVeHYMcv8ATV5d508CFdn+8/pHPpXeIid1DdrPwXnaAdH7cqjVbpJaT5eq4yRAFU/lsbwYwSF/n5iNrdJHPQA==} engines: {node: '>=14'} @@ -6245,6 +6608,11 @@ packages: rfdc@1.4.1: resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==} + rimraf@2.7.1: + resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} + deprecated: Rimraf versions prior to v4 are no longer supported + hasBin: true + rimraf@3.0.2: resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} deprecated: Rimraf versions prior to v4 are no longer supported @@ -6287,6 +6655,10 @@ packages: rxjs@7.8.1: resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} + sade@1.8.1: + resolution: {integrity: sha512-xal3CZX1Xlo/k4ApwCFrHVACi9fBqJ7V+mwhBsuf/1IOKbBy098Fex+Wa/5QMubw09pSZ/u8EY8PWgevJsXp1A==} + engines: {node: '>=6'} + safe-buffer@5.1.2: resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} @@ -6296,6 +6668,9 @@ packages: safer-buffer@2.1.2: resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + sander@0.5.1: + resolution: {integrity: sha512-3lVqBir7WuKDHGrKRDn/1Ye3kwpXaDOMsiRP1wd6wpZW56gJhsbp5RqQpA6JG/P+pkXizygnr1dKR8vzWaVsfA==} + sass-loader@14.1.1: resolution: {integrity: sha512-QX8AasDg75monlybel38BZ49JP5Z+uSKfKwF2rO7S74BywaRmGQMUBw9dtkS+ekyM/QnP+NOrRYq8ABMZ9G8jw==} engines: {node: '>= 18.12.0'} @@ -6375,6 +6750,16 @@ packages: serialize-javascript@6.0.2: resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==} + seroval-plugins@1.1.1: + resolution: {integrity: sha512-qNSy1+nUj7hsCOon7AO4wdAIo9P0jrzAMp18XhiOzA6/uO5TKtP7ScozVJ8T293oRIvi5wyCHSM4TrJo/c/GJA==} + engines: {node: '>=10'} + peerDependencies: + seroval: ^1.0 + + seroval@1.1.1: + resolution: {integrity: sha512-rqEO6FZk8mv7Hyv4UCj3FD3b6Waqft605TLfsCe/BiaylRpyyMC0b+uA5TJKawX3KzMrdi3wsLbCaLplrQmBvQ==} + engines: {node: '>=10'} + serve-index@1.9.1: resolution: {integrity: sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==} engines: {node: '>= 0.8.0'} @@ -6383,6 +6768,9 @@ packages: resolution: {integrity: sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==} engines: {node: '>= 0.8.0'} + set-cookie-parser@2.7.0: + resolution: {integrity: sha512-lXLOiqpkUumhRdFF3k1osNXCy9akgx/dyPZ5p8qAg9seJzXr5ZrlqZuWIMuY6ejOsVLE6flJ5/h3lsn57fQ/PQ==} + set-function-length@1.2.2: resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} engines: {node: '>= 0.4'} @@ -6475,6 +6863,13 @@ packages: resolution: {integrity: sha512-l5x7VUUWbjVFbafGLxPWkYsHIhEvmF85tbIeFZWc8ZPtoMyybuEhL7Jye/ooC4/d48FgOjSJXgsF/AJPYCW8Zw==} engines: {node: '>= 10.0.0', npm: '>= 3.0.0'} + solid-js@1.8.20: + resolution: {integrity: sha512-SsgaExCJ97mPm9WpAusjZ484Z8zTp8ggiueQOsrm81iAP7UaxaN+wiOgnPcJ9u6B2SQpoQ4FiDPAZBqVWi1V4g==} + + sorcery@0.11.1: + resolution: {integrity: sha512-o7npfeJE6wi6J9l0/5LKshFzZ2rMatRiCDwYeDQaOzqdzRJwALhX7mk/A/ecg6wjMu7wdZbmXfD2S/vpOg0bdQ==} + hasBin: true + source-map-js@1.2.0: resolution: {integrity: sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==} engines: {node: '>=0.10.0'} @@ -6591,6 +6986,10 @@ packages: resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==} engines: {node: '>=12'} + strip-indent@3.0.0: + resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} + engines: {node: '>=8'} + strip-json-comments@3.1.1: resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} engines: {node: '>=8'} @@ -6623,6 +7022,68 @@ packages: resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} engines: {node: '>= 0.4'} + svelte-check@3.6.0: + resolution: {integrity: sha512-8VfqhfuRJ1sKW+o8isH2kPi0RhjXH1nNsIbCFGyoUHG+ZxVxHYRKcb+S8eaL/1tyj3VGvWYx3Y5+oCUsJgnzcw==} + hasBin: true + peerDependencies: + svelte: ^3.55.0 || ^4.0.0-next.0 || ^4.0.0 || ^5.0.0-next.0 + + svelte-eslint-parser@0.41.0: + resolution: {integrity: sha512-L6f4hOL+AbgfBIB52Z310pg1d2QjRqm7wy3kI1W6hhdhX5bvu7+f0R6w4ykp5HoDdzq+vGhIJmsisaiJDGmVfA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + svelte: ^3.37.0 || ^4.0.0 || ^5.0.0-next.191 + peerDependenciesMeta: + svelte: + optional: true + + svelte-hmr@0.15.3: + resolution: {integrity: sha512-41snaPswvSf8TJUhlkoJBekRrABDXDMdpNpT2tfHIv4JuhgvHqLMhEPGtaQn0BmbNSTkuz2Ed20DF2eHw0SmBQ==} + engines: {node: ^12.20 || ^14.13.1 || >= 16} + peerDependencies: + svelte: ^3.19.0 || ^4.0.0 + + svelte-preprocess@5.1.4: + resolution: {integrity: sha512-IvnbQ6D6Ao3Gg6ftiM5tdbR6aAETwjhHV+UKGf5bHGYR69RQvF1ho0JKPcbUON4vy4R7zom13jPjgdOWCQ5hDA==} + engines: {node: '>= 16.0.0'} + peerDependencies: + '@babel/core': ^7.10.2 + coffeescript: ^2.5.1 + less: ^3.11.3 || ^4.0.0 + postcss: ^7 || ^8 + postcss-load-config: ^2.1.0 || ^3.0.0 || ^4.0.0 || ^5.0.0 + pug: ^3.0.0 + sass: ^1.26.8 + stylus: ^0.55.0 + sugarss: ^2.0.0 || ^3.0.0 || ^4.0.0 + svelte: ^3.23.0 || ^4.0.0-next.0 || ^4.0.0 || ^5.0.0-next.0 + typescript: '>=3.9.5 || ^4.0.0 || ^5.0.0' + peerDependenciesMeta: + '@babel/core': + optional: true + coffeescript: + optional: true + less: + optional: true + postcss: + optional: true + postcss-load-config: + optional: true + pug: + optional: true + sass: + optional: true + stylus: + optional: true + sugarss: + optional: true + typescript: + optional: true + + svelte@4.2.7: + resolution: {integrity: sha512-UExR1KS7raTdycsUrKLtStayu4hpdV3VZQgM0akX8XbXgLBlosdE/Sf3crOgyh9xIjqSYB3UEBuUlIQKRQX2hg==} + engines: {node: '>=16'} + svg-tags@1.0.0: resolution: {integrity: sha512-ovssysQTa+luh7A5Weu3Rta6FJlFBBbInjOh722LIt6klpU2/HtdUbszju/G4devcvk8PGt7FCLv5wftu3THUA==} @@ -6712,6 +7173,9 @@ packages: thunky@1.1.0: resolution: {integrity: sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==} + tiny-glob@0.2.9: + resolution: {integrity: sha512-g/55ssRPUjShh+xkfx9UPDXqhckHEsHr4Vd9zX55oSdGZc/MD0m3sferOkwWtp98bv+kcVfEHtRJgBVJzelrzg==} + tinybench@2.8.0: resolution: {integrity: sha512-1/eK7zUnIklz4JUUlL+658n58XO2hHLQfSk1Zf2LKieUjxidN16eKFEoDEfjHc3ohofSSqK3X5yO6VGb6iW8Lw==} @@ -6719,10 +7183,18 @@ packages: resolution: {integrity: sha512-i11VH5gS6IFeLY3gMBQ00/MmLncVP7JLXOw1vlgkytLmJK7QnEr7NXf0LBdxfmNPAeyetukOk0bOYrJrFGjYJQ==} engines: {node: '>=14.0.0'} + tinypool@1.0.0: + resolution: {integrity: sha512-KIKExllK7jp3uvrNtvRBYBWBOAXSX8ZvoaD8T+7KB/QHIuoJW3Pmr60zucywjAlMb5TeXUkcs/MWeWLu0qvuAQ==} + engines: {node: ^18.0.0 || >=20.0.0} + tinyspy@2.2.1: resolution: {integrity: sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==} engines: {node: '>=14.0.0'} + tinyspy@3.0.0: + resolution: {integrity: sha512-q5nmENpTHgiPVd1cJDDc9cVoYN5x4vCvwT3FMilvKPKneCBZAxn2YWQjDF0UMcE9k0Cay1gBiDfTMU0g+mPMQA==} + engines: {node: '>=14.0.0'} + tmp@0.0.33: resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} engines: {node: '>=0.6.0'} @@ -6833,6 +7305,15 @@ packages: typescript: optional: true + typescript-eslint@8.0.0: + resolution: {integrity: sha512-yQWBJutWL1PmpmDddIOl9/Mi6vZjqNCjqSGBMQ4vsc2Aiodk0SnbQQWPXbSy0HNuKCuGkw1+u4aQ2mO40TdhDQ==} + engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + typescript@5.5.3: resolution: {integrity: sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==} engines: {node: '>=14.17'} @@ -6966,6 +7447,11 @@ packages: engines: {node: ^18.0.0 || >=20.0.0} hasBin: true + vite-node@2.0.0: + resolution: {integrity: sha512-jZtezmjcgZTkMisIi68TdY8w/PqPTxK2pbfTU9/4Gqus1K3AVZqkwH0z7Vshe3CD6mq9rJq8SpqmuefDMIqkfQ==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + vite-plugin-inspect@0.8.5: resolution: {integrity: sha512-JvTUqsP1JNDw0lMZ5Z/r5cSj81VK2B7884LO1DC3GMBhdcjcsAnJjdWq7bzQL01Xbh+v60d3lju3g+z7eAtNew==} engines: {node: '>=14'} @@ -6987,6 +7473,34 @@ packages: peerDependencies: vite: ^3.0.0-0 || ^4.0.0-0 || ^5.0.0-0 + vite@5.0.3: + resolution: {integrity: sha512-WgEq8WEKpZ8c0DL4M1+E+kBZEJyjBmGVrul6z8Ljfhv+PPbNF4aGq014DwNYxGz2FGq6NKL0N8usdiESWd2l2w==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@types/node': ^18.0.0 || >=20.0.0 + less: '*' + lightningcss: ^1.21.0 + sass: '*' + stylus: '*' + sugarss: '*' + terser: ^5.4.0 + peerDependenciesMeta: + '@types/node': + optional: true + less: + optional: true + lightningcss: + optional: true + sass: + optional: true + stylus: + optional: true + sugarss: + optional: true + terser: + optional: true + vite@5.1.7: resolution: {integrity: sha512-sgnEEFTZYMui/sTlH1/XEnVNHMujOahPLGMxn1+5sIT45Xjng1Ec1K78jRP15dSmVgg5WBin9yO81j3o9OxofA==} engines: {node: ^18.0.0 || >=20.0.0} @@ -7043,6 +7557,14 @@ packages: terser: optional: true + vitefu@0.2.5: + resolution: {integrity: sha512-SgHtMLoqaeeGnd2evZ849ZbACbnwQCIwRH57t18FxcXoZop0uQu0uzlIhJBlF/eWVzuce0sHeqPcDo+evVcg8Q==} + peerDependencies: + vite: ^3.0.0 || ^4.0.0 || ^5.0.0 + peerDependenciesMeta: + vite: + optional: true + vitepress@1.3.0: resolution: {integrity: sha512-Cbm2AgXcCrukUeV+/24g1ZDSvw8blamh/1uf2pz3ApFpaYb9T7mo4imWDZ6APn2uPo4bJ6sgOzvsJ4aH+oLbBA==} hasBin: true @@ -7080,6 +7602,31 @@ packages: jsdom: optional: true + vitest@2.0.0: + resolution: {integrity: sha512-NvccE2tZhIoPSq3o3AoTBmItwhHNjzIxvOgfdzILIscyzSGOtw2+A1d/JJbS86HDVbc6TS5HnckQuCgTfp0HDQ==} + engines: {node: ^18.0.0 || >=20.0.0} + hasBin: true + peerDependencies: + '@edge-runtime/vm': '*' + '@types/node': ^18.0.0 || >=20.0.0 + '@vitest/browser': 2.0.0 + '@vitest/ui': 2.0.0 + happy-dom: '*' + jsdom: '*' + peerDependenciesMeta: + '@edge-runtime/vm': + optional: true + '@types/node': + optional: true + '@vitest/browser': + optional: true + '@vitest/ui': + optional: true + happy-dom: + optional: true + jsdom: + optional: true + vscode-uri@3.0.8: resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==} @@ -7249,6 +7796,11 @@ packages: engines: {node: '>=8'} hasBin: true + why-is-node-running@2.3.0: + resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==} + engines: {node: '>=8'} + hasBin: true + wildcard@2.0.1: resolution: {integrity: sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==} @@ -7314,6 +7866,10 @@ packages: yallist@4.0.0: resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} + yaml@1.10.2: + resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==} + engines: {node: '>= 6'} + yaml@2.4.5: resolution: {integrity: sha512-aBx2bnqDzVOyNKfsysjA2ms5ZlnjSAW2eG3/L5G/CSujfjLJTJsEw1bGw8kCf04KodQWk1pxlGnZ56CRxiawmg==} engines: {node: '>= 14'} @@ -9095,6 +9651,11 @@ snapshots: '@esbuild/win32-x64@0.21.5': optional: true + '@eslint-community/eslint-utils@4.4.0(eslint@9.0.0)': + dependencies: + eslint: 9.0.0 + eslint-visitor-keys: 3.4.3 + '@eslint-community/eslint-utils@4.4.0(eslint@9.6.0)': dependencies: eslint: 9.6.0 @@ -9124,6 +9685,8 @@ snapshots: transitivePeerDependencies: - supports-color + '@eslint/js@9.0.0': {} + '@eslint/js@9.6.0': {} '@eslint/object-schema@2.1.4': {} @@ -9145,8 +9708,20 @@ snapshots: '@floating-ui/utils@0.2.2': {} + '@fontsource/fira-mono@5.0.0': {} + + '@humanwhocodes/config-array@0.12.3': + dependencies: + '@humanwhocodes/object-schema': 2.0.3 + debug: 4.3.5 + minimatch: 3.1.2 + transitivePeerDependencies: + - supports-color + '@humanwhocodes/module-importer@1.0.1': {} + '@humanwhocodes/object-schema@2.0.3': {} + '@humanwhocodes/retry@0.3.0': {} '@isaacs/cliui@8.0.2': @@ -9223,6 +9798,8 @@ snapshots: globby: 11.1.0 read-yaml-file: 1.1.0 + '@neoconfetti/svelte@2.0.0': {} + '@ngtools/webpack@17.3.7(@angular/compiler-cli@17.3.9(@angular/compiler@17.3.9(@angular/core@17.3.9(rxjs@7.8.1)(zone.js@0.14.7)))(typescript@5.5.3))(typescript@5.5.3)(webpack@5.90.3(esbuild@0.20.1))': dependencies: '@angular/compiler-cli': 17.3.9(@angular/compiler@17.3.9(@angular/core@17.3.9(rxjs@7.8.1)(zone.js@0.14.7)))(typescript@5.5.3) @@ -10130,6 +10707,51 @@ snapshots: '@stackblitz/sdk@1.11.0': {} + '@sveltejs/adapter-auto@3.0.0(@sveltejs/kit@2.0.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))': + dependencies: + '@sveltejs/kit': 2.0.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + import-meta-resolve: 4.1.0 + + '@sveltejs/kit@2.0.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1))': + dependencies: + '@sveltejs/vite-plugin-svelte': 3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + '@types/cookie': 0.6.0 + cookie: 0.6.0 + devalue: 4.3.3 + esm-env: 1.0.0 + kleur: 4.1.5 + magic-string: 0.30.10 + mrmime: 1.0.1 + sade: 1.8.1 + set-cookie-parser: 2.7.0 + sirv: 2.0.4 + svelte: 4.2.7 + tiny-glob: 0.2.9 + vite: 5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + + '@sveltejs/vite-plugin-svelte-inspector@2.1.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1))': + dependencies: + '@sveltejs/vite-plugin-svelte': 3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + debug: 4.3.5 + svelte: 4.2.7 + vite: 5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + transitivePeerDependencies: + - supports-color + + '@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1))': + dependencies: + '@sveltejs/vite-plugin-svelte-inspector': 2.1.0(@sveltejs/vite-plugin-svelte@3.0.0(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)))(svelte@4.2.7)(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + debug: 4.3.5 + deepmerge: 4.3.1 + kleur: 4.1.5 + magic-string: 0.30.10 + svelte: 4.2.7 + svelte-hmr: 0.15.3(svelte@4.2.7) + vite: 5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + vitefu: 0.2.5(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)) + transitivePeerDependencies: + - supports-color + '@tanstack/match-sorter-utils@8.19.4': dependencies: remove-accents: 0.5.0 @@ -10149,6 +10771,16 @@ snapshots: '@tanstack/query-core': 5.51.21 react: 18.3.1 + '@tanstack/solid-query@5.51.21(solid-js@1.8.20)': + dependencies: + '@tanstack/query-core': 5.51.21 + solid-js: 1.8.20 + + '@tanstack/svelte-query@5.51.21(svelte@4.2.7)': + dependencies: + '@tanstack/query-core': 5.51.21 + svelte: 4.2.7 + '@tanstack/vue-query-devtools@5.51.21(@tanstack/vue-query@5.51.21(vue@3.4.37(typescript@5.5.3)))(vue@3.4.37(typescript@5.5.3))': dependencies: '@tanstack/query-devtools': 5.51.16 @@ -10221,16 +10853,18 @@ snapshots: dependencies: '@types/node': 20.14.10 + '@types/cookie@0.6.0': {} + '@types/cross-spawn@6.0.6': dependencies: '@types/node': 20.14.10 '@types/eslint-scope@3.7.7': dependencies: - '@types/eslint': 8.56.10 + '@types/eslint': 9.6.0 '@types/estree': 1.0.5 - '@types/eslint@8.56.10': + '@types/eslint@9.6.0': dependencies: '@types/estree': 1.0.5 '@types/json-schema': 7.0.15 @@ -10296,6 +10930,8 @@ snapshots: '@types/prop-types@15.7.12': {} + '@types/pug@2.0.10': {} + '@types/qs@6.9.15': {} '@types/range-parser@1.2.7': {} @@ -10367,6 +11003,24 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/eslint-plugin@8.0.0(@typescript-eslint/parser@8.0.0(eslint@9.0.0)(typescript@5.5.3))(eslint@9.0.0)(typescript@5.5.3)': + dependencies: + '@eslint-community/regexpp': 4.11.0 + '@typescript-eslint/parser': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + '@typescript-eslint/scope-manager': 8.0.0 + '@typescript-eslint/type-utils': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + '@typescript-eslint/utils': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + '@typescript-eslint/visitor-keys': 8.0.0 + eslint: 9.0.0 + graphemer: 1.4.0 + ignore: 5.3.1 + natural-compare: 1.4.0 + ts-api-utils: 1.3.0(typescript@5.5.3) + optionalDependencies: + typescript: 5.5.3 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/experimental-utils@5.62.0(eslint@9.6.0)(typescript@5.5.3)': dependencies: '@typescript-eslint/utils': 5.62.0(eslint@9.6.0)(typescript@5.5.3) @@ -10388,6 +11042,19 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/parser@8.0.0(eslint@9.0.0)(typescript@5.5.3)': + dependencies: + '@typescript-eslint/scope-manager': 8.0.0 + '@typescript-eslint/types': 8.0.0 + '@typescript-eslint/typescript-estree': 8.0.0(typescript@5.5.3) + '@typescript-eslint/visitor-keys': 8.0.0 + debug: 4.3.5 + eslint: 9.0.0 + optionalDependencies: + typescript: 5.5.3 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/scope-manager@5.62.0': dependencies: '@typescript-eslint/types': 5.62.0 @@ -10398,6 +11065,11 @@ snapshots: '@typescript-eslint/types': 7.15.0 '@typescript-eslint/visitor-keys': 7.15.0 + '@typescript-eslint/scope-manager@8.0.0': + dependencies: + '@typescript-eslint/types': 8.0.0 + '@typescript-eslint/visitor-keys': 8.0.0 + '@typescript-eslint/type-utils@7.15.0(eslint@9.6.0)(typescript@5.5.3)': dependencies: '@typescript-eslint/typescript-estree': 7.15.0(typescript@5.5.3) @@ -10410,10 +11082,24 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/type-utils@8.0.0(eslint@9.0.0)(typescript@5.5.3)': + dependencies: + '@typescript-eslint/typescript-estree': 8.0.0(typescript@5.5.3) + '@typescript-eslint/utils': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + debug: 4.3.5 + ts-api-utils: 1.3.0(typescript@5.5.3) + optionalDependencies: + typescript: 5.5.3 + transitivePeerDependencies: + - eslint + - supports-color + '@typescript-eslint/types@5.62.0': {} '@typescript-eslint/types@7.15.0': {} + '@typescript-eslint/types@8.0.0': {} + '@typescript-eslint/typescript-estree@5.62.0(typescript@5.5.3)': dependencies: '@typescript-eslint/types': 5.62.0 @@ -10443,6 +11129,21 @@ snapshots: transitivePeerDependencies: - supports-color + '@typescript-eslint/typescript-estree@8.0.0(typescript@5.5.3)': + dependencies: + '@typescript-eslint/types': 8.0.0 + '@typescript-eslint/visitor-keys': 8.0.0 + debug: 4.3.5 + globby: 11.1.0 + is-glob: 4.0.3 + minimatch: 9.0.5 + semver: 7.6.2 + ts-api-utils: 1.3.0(typescript@5.5.3) + optionalDependencies: + typescript: 5.5.3 + transitivePeerDependencies: + - supports-color + '@typescript-eslint/utils@5.62.0(eslint@9.6.0)(typescript@5.5.3)': dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@9.6.0) @@ -10469,6 +11170,17 @@ snapshots: - supports-color - typescript + '@typescript-eslint/utils@8.0.0(eslint@9.0.0)(typescript@5.5.3)': + dependencies: + '@eslint-community/eslint-utils': 4.4.0(eslint@9.0.0) + '@typescript-eslint/scope-manager': 8.0.0 + '@typescript-eslint/types': 8.0.0 + '@typescript-eslint/typescript-estree': 8.0.0(typescript@5.5.3) + eslint: 9.0.0 + transitivePeerDependencies: + - supports-color + - typescript + '@typescript-eslint/visitor-keys@5.62.0': dependencies: '@typescript-eslint/types': 5.62.0 @@ -10479,6 +11191,11 @@ snapshots: '@typescript-eslint/types': 7.15.0 eslint-visitor-keys: 3.4.3 + '@typescript-eslint/visitor-keys@8.0.0': + dependencies: + '@typescript-eslint/types': 8.0.0 + eslint-visitor-keys: 3.4.3 + '@vitejs/plugin-basic-ssl@1.1.0(vite@5.1.7(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.29.1))': dependencies: vite: 5.1.7(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.29.1) @@ -10539,22 +11256,43 @@ snapshots: '@vitest/utils': 1.6.0 chai: 4.4.1 + '@vitest/expect@2.0.0': + dependencies: + '@vitest/spy': 2.0.0 + '@vitest/utils': 2.0.0 + chai: 5.1.1 + '@vitest/runner@1.6.0': dependencies: '@vitest/utils': 1.6.0 p-limit: 5.0.0 pathe: 1.1.2 + '@vitest/runner@2.0.0': + dependencies: + '@vitest/utils': 2.0.0 + pathe: 1.1.2 + '@vitest/snapshot@1.6.0': dependencies: magic-string: 0.30.10 pathe: 1.1.2 pretty-format: 29.7.0 + '@vitest/snapshot@2.0.0': + dependencies: + magic-string: 0.30.10 + pathe: 1.1.2 + pretty-format: 29.7.0 + '@vitest/spy@1.6.0': dependencies: tinyspy: 2.2.1 + '@vitest/spy@2.0.0': + dependencies: + tinyspy: 3.0.0 + '@vitest/utils@1.6.0': dependencies: diff-sequences: 29.6.3 @@ -10562,6 +11300,13 @@ snapshots: loupe: 2.3.7 pretty-format: 29.7.0 + '@vitest/utils@2.0.0': + dependencies: + diff-sequences: 29.6.3 + estree-walker: 3.0.3 + loupe: 3.1.1 + pretty-format: 29.7.0 + '@volar/language-core@2.4.0-alpha.18': dependencies: '@volar/source-map': 2.4.0-alpha.18 @@ -10680,11 +11425,11 @@ snapshots: dependencies: rfdc: 1.4.1 - '@vue/eslint-config-prettier@9.0.0(@types/eslint@8.56.10)(eslint@9.6.0)(prettier@3.3.2)': + '@vue/eslint-config-prettier@9.0.0(@types/eslint@9.6.0)(eslint@9.6.0)(prettier@3.3.2)': dependencies: eslint: 9.6.0 eslint-config-prettier: 9.1.0(eslint@9.6.0) - eslint-plugin-prettier: 5.2.1(@types/eslint@8.56.10)(eslint-config-prettier@9.1.0(eslint@9.6.0))(eslint@9.6.0)(prettier@3.3.2) + eslint-plugin-prettier: 5.2.1(@types/eslint@9.6.0)(eslint-config-prettier@9.1.0(eslint@9.6.0))(eslint@9.6.0)(prettier@3.3.2) prettier: 3.3.2 transitivePeerDependencies: - '@types/eslint' @@ -11006,12 +11751,18 @@ snapshots: dependencies: tslib: 2.6.3 + aria-query@5.3.0: + dependencies: + dequal: 2.0.3 + array-flatten@1.1.1: {} array-union@2.1.0: {} assertion-error@1.1.0: {} + assertion-error@2.0.1: {} + ast-types@0.13.4: dependencies: tslib: 2.6.3 @@ -11046,6 +11797,8 @@ snapshots: transitivePeerDependencies: - debug + axobject-query@3.2.4: {} + b4a@1.6.6: {} babel-loader@9.1.3(@babel/core@7.24.0)(webpack@5.90.3(esbuild@0.20.1)): @@ -11182,6 +11935,8 @@ snapshots: buffer-crc32@0.2.13: {} + buffer-crc32@1.0.0: {} + buffer-from@1.1.2: {} buffer@5.7.1: @@ -11261,6 +12016,14 @@ snapshots: pathval: 1.1.1 type-detect: 4.0.8 + chai@5.1.1: + dependencies: + assertion-error: 2.0.1 + check-error: 2.1.1 + deep-eql: 5.0.2 + loupe: 3.1.1 + pathval: 2.0.0 + chalk@2.4.2: dependencies: ansi-styles: 3.2.1 @@ -11280,6 +12043,8 @@ snapshots: dependencies: get-func-name: 2.0.2 + check-error@2.1.1: {} + chokidar@3.6.0: dependencies: anymatch: 3.1.3 @@ -11344,6 +12109,14 @@ snapshots: clone@1.0.4: {} + code-red@1.0.4: + dependencies: + '@jridgewell/sourcemap-codec': 1.4.15 + '@types/estree': 1.0.5 + acorn: 8.12.0 + estree-walker: 3.0.3 + periscopic: 3.1.0 + color-convert@1.9.3: dependencies: color-name: 1.1.3 @@ -11497,6 +12270,11 @@ snapshots: domutils: 3.1.0 nth-check: 2.1.1 + css-tree@2.3.1: + dependencies: + mdn-data: 2.0.30 + source-map-js: 1.2.0 + css-what@6.1.0: {} cssesc@3.0.0: {} @@ -11538,6 +12316,8 @@ snapshots: dependencies: type-detect: 4.0.8 + deep-eql@5.0.2: {} + deep-is@0.1.4: {} deepmerge@4.3.1: {} @@ -11581,6 +12361,8 @@ snapshots: depd@2.0.0: {} + dequal@2.0.3: {} + destr@2.0.3: {} destroy@1.2.0: {} @@ -11591,6 +12373,8 @@ snapshots: detect-node@2.1.0: {} + devalue@4.3.3: {} + devtools-protocol@0.0.1299070: {} didyoumean@1.2.2: {} @@ -11700,6 +12484,8 @@ snapshots: es-module-lexer@1.5.3: {} + es6-promise@3.3.1: {} + esbuild-wasm@0.20.1: {} esbuild@0.19.12: @@ -11797,18 +12583,27 @@ snapshots: optionalDependencies: source-map: 0.6.1 + eslint-compat-utils@0.5.1(eslint@9.0.0): + dependencies: + eslint: 9.0.0 + semver: 7.6.2 + + eslint-config-prettier@9.1.0(eslint@9.0.0): + dependencies: + eslint: 9.0.0 + eslint-config-prettier@9.1.0(eslint@9.6.0): dependencies: eslint: 9.6.0 - eslint-plugin-prettier@5.2.1(@types/eslint@8.56.10)(eslint-config-prettier@9.1.0(eslint@9.6.0))(eslint@9.6.0)(prettier@3.3.2): + eslint-plugin-prettier@5.2.1(@types/eslint@9.6.0)(eslint-config-prettier@9.1.0(eslint@9.6.0))(eslint@9.6.0)(prettier@3.3.2): dependencies: eslint: 9.6.0 prettier: 3.3.2 prettier-linter-helpers: 1.0.0 synckit: 0.9.1 optionalDependencies: - '@types/eslint': 8.56.10 + '@types/eslint': 9.6.0 eslint-config-prettier: 9.1.0(eslint@9.6.0) eslint-plugin-react-hooks@4.6.2(eslint@9.6.0): @@ -11830,6 +12625,27 @@ snapshots: natural-compare: 1.4.0 requireindex: 1.2.0 + eslint-plugin-svelte@2.36.0(eslint@9.0.0)(svelte@4.2.7)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): + dependencies: + '@eslint-community/eslint-utils': 4.4.0(eslint@9.0.0) + '@jridgewell/sourcemap-codec': 1.4.15 + debug: 4.3.5 + eslint: 9.0.0 + eslint-compat-utils: 0.5.1(eslint@9.0.0) + esutils: 2.0.3 + known-css-properties: 0.30.0 + postcss: 8.4.39 + postcss-load-config: 3.1.4(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)) + postcss-safe-parser: 6.0.0(postcss@8.4.39) + postcss-selector-parser: 6.1.0 + semver: 7.6.2 + svelte-eslint-parser: 0.41.0(svelte@4.2.7) + optionalDependencies: + svelte: 4.2.7 + transitivePeerDependencies: + - supports-color + - ts-node + eslint-plugin-typescript-sort-keys@3.2.0(@typescript-eslint/parser@7.15.0(eslint@9.6.0)(typescript@5.5.3))(eslint@9.6.0)(typescript@5.5.3): dependencies: '@typescript-eslint/experimental-utils': 5.62.0(eslint@9.6.0)(typescript@5.5.3) @@ -11889,6 +12705,45 @@ snapshots: eslint-visitor-keys@4.0.0: {} + eslint@9.0.0: + dependencies: + '@eslint-community/eslint-utils': 4.4.0(eslint@9.0.0) + '@eslint-community/regexpp': 4.11.0 + '@eslint/eslintrc': 3.1.0 + '@eslint/js': 9.0.0 + '@humanwhocodes/config-array': 0.12.3 + '@humanwhocodes/module-importer': 1.0.1 + '@nodelib/fs.walk': 1.2.8 + ajv: 6.12.6 + chalk: 4.1.2 + cross-spawn: 7.0.3 + debug: 4.3.5 + escape-string-regexp: 4.0.0 + eslint-scope: 8.0.1 + eslint-visitor-keys: 4.0.0 + espree: 10.1.0 + esquery: 1.5.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 8.0.0 + find-up: 5.0.0 + glob-parent: 6.0.2 + graphemer: 1.4.0 + ignore: 5.3.1 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + is-path-inside: 3.0.3 + json-stable-stringify-without-jsonify: 1.0.1 + levn: 0.4.1 + lodash.merge: 4.6.2 + minimatch: 3.1.2 + natural-compare: 1.4.0 + optionator: 0.9.4 + strip-ansi: 6.0.1 + text-table: 0.2.0 + transitivePeerDependencies: + - supports-color + eslint@9.6.0: dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@9.6.0) @@ -11928,6 +12783,8 @@ snapshots: transitivePeerDependencies: - supports-color + esm-env@1.0.0: {} + espree@10.1.0: dependencies: acorn: 8.12.0 @@ -12295,8 +13152,12 @@ snapshots: globals@14.0.0: {} + globals@15.0.0: {} + globals@15.8.0: {} + globalyzer@0.1.0: {} + globby@11.1.0: dependencies: array-union: 2.1.0 @@ -12314,6 +13175,8 @@ snapshots: merge2: 1.4.1 slash: 4.0.0 + globrex@0.1.2: {} + gopd@1.0.1: dependencies: get-intrinsic: 1.2.4 @@ -12474,6 +13337,8 @@ snapshots: parent-module: 1.0.1 resolve-from: 4.0.0 + import-meta-resolve@4.1.0: {} + imurmurhash@0.1.4: {} indent-string@4.0.0: {} @@ -12580,6 +13445,10 @@ snapshots: dependencies: '@types/estree': 1.0.5 + is-reference@3.0.2: + dependencies: + '@types/estree': 1.0.5 + is-stream@2.0.1: {} is-stream@3.0.0: {} @@ -12754,8 +13623,12 @@ snapshots: kind-of@6.0.3: {} + kleur@4.1.5: {} + klona@2.0.6: {} + known-css-properties@0.30.0: {} + kolorist@1.8.0: {} launch-editor@2.8.0: @@ -12846,6 +13719,8 @@ snapshots: mlly: 1.7.1 pkg-types: 1.1.1 + locate-character@3.0.0: {} + locate-path@5.0.0: dependencies: p-locate: 4.1.0 @@ -12887,6 +13762,10 @@ snapshots: dependencies: get-func-name: 2.0.2 + loupe@3.1.1: + dependencies: + get-func-name: 2.0.2 + lru-cache@10.4.0: {} lru-cache@4.1.5: @@ -12949,6 +13828,8 @@ snapshots: mark.js@8.11.1: {} + mdn-data@2.0.30: {} + media-typer@0.3.0: {} memfs@3.5.3: @@ -12982,6 +13863,8 @@ snapshots: mimic-fn@4.0.0: {} + min-indent@1.0.1: {} + mini-css-extract-plugin@2.8.1(webpack@5.90.3(esbuild@0.20.1)): dependencies: schema-utils: 4.2.0 @@ -13050,6 +13933,10 @@ snapshots: mitt@3.0.1: {} + mkdirp@0.5.6: + dependencies: + minimist: 1.2.8 + mkdirp@1.0.4: {} mlly@1.7.1: @@ -13061,6 +13948,8 @@ snapshots: mri@1.2.0: {} + mrmime@1.0.1: {} + mrmime@2.0.0: {} ms@2.0.0: {} @@ -13448,10 +14337,18 @@ snapshots: pathval@1.1.1: {} + pathval@2.0.0: {} + pend@1.2.0: {} perfect-debounce@1.0.0: {} + periscopic@3.1.0: + dependencies: + '@types/estree': 1.0.5 + estree-walker: 3.0.3 + is-reference: 3.0.2 + picocolors@1.0.1: {} picomatch@2.3.1: {} @@ -13504,6 +14401,23 @@ snapshots: camelcase-css: 2.0.1 postcss: 8.4.41 + postcss-load-config@3.1.4(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): + dependencies: + lilconfig: 2.1.0 + yaml: 1.10.2 + optionalDependencies: + postcss: 8.4.39 + ts-node: 10.9.2(@types/node@20.14.10)(typescript@5.5.3) + + postcss-load-config@4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): + dependencies: + lilconfig: 3.1.2 + yaml: 2.4.5 + optionalDependencies: + postcss: 8.4.39 + ts-node: 10.9.2(@types/node@20.14.10)(typescript@5.5.3) + optional: true + postcss-load-config@4.0.2(postcss@8.4.41)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)): dependencies: lilconfig: 3.1.2 @@ -13551,6 +14465,14 @@ snapshots: postcss: 8.4.41 postcss-selector-parser: 6.1.0 + postcss-safe-parser@6.0.0(postcss@8.4.39): + dependencies: + postcss: 8.4.39 + + postcss-scss@4.0.9(postcss@8.4.39): + dependencies: + postcss: 8.4.39 + postcss-selector-parser@6.1.0: dependencies: cssesc: 3.0.0 @@ -13591,8 +14513,15 @@ snapshots: dependencies: fast-diff: 1.3.0 + prettier-plugin-svelte@3.1.2(prettier@3.1.1)(svelte@4.2.7): + dependencies: + prettier: 3.1.1 + svelte: 4.2.7 + prettier@2.8.8: {} + prettier@3.1.1: {} + prettier@3.3.2: {} pretty-format@29.7.0: @@ -13864,6 +14793,10 @@ snapshots: rfdc@1.4.1: {} + rimraf@2.7.1: + dependencies: + glob: 7.2.3 + rimraf@3.0.2: dependencies: glob: 7.2.3 @@ -13918,12 +14851,23 @@ snapshots: dependencies: tslib: 2.6.3 + sade@1.8.1: + dependencies: + mri: 1.2.0 + safe-buffer@5.1.2: {} safe-buffer@5.2.1: {} safer-buffer@2.1.2: {} + sander@0.5.1: + dependencies: + es6-promise: 3.3.1 + graceful-fs: 4.2.11 + mkdirp: 0.5.6 + rimraf: 2.7.1 + sass-loader@14.1.1(sass@1.71.1)(webpack@5.90.3(esbuild@0.20.1)): dependencies: neo-async: 2.6.2 @@ -14003,6 +14947,12 @@ snapshots: dependencies: randombytes: 2.1.0 + seroval-plugins@1.1.1(seroval@1.1.1): + dependencies: + seroval: 1.1.1 + + seroval@1.1.1: {} + serve-index@1.9.1: dependencies: accepts: 1.3.8 @@ -14024,6 +14974,8 @@ snapshots: transitivePeerDependencies: - supports-color + set-cookie-parser@2.7.0: {} + set-function-length@1.2.2: dependencies: define-data-property: 1.1.4 @@ -14127,6 +15079,19 @@ snapshots: ip-address: 9.0.5 smart-buffer: 4.2.0 + solid-js@1.8.20: + dependencies: + csstype: 3.1.3 + seroval: 1.1.1 + seroval-plugins: 1.1.1(seroval@1.1.1) + + sorcery@0.11.1: + dependencies: + '@jridgewell/sourcemap-codec': 1.4.15 + buffer-crc32: 1.0.0 + minimist: 1.2.8 + sander: 0.5.1 + source-map-js@1.2.0: {} source-map-loader@5.0.0(webpack@5.90.3(esbuild@0.20.1)): @@ -14252,6 +15217,10 @@ snapshots: strip-final-newline@3.0.0: {} + strip-indent@3.0.0: + dependencies: + min-indent: 1.0.1 + strip-json-comments@3.1.1: {} strip-literal@2.1.0: @@ -14286,6 +15255,74 @@ snapshots: supports-preserve-symlinks-flag@1.0.0: {} + svelte-check@3.6.0(@babel/core@7.24.7)(less@4.2.0)(postcss-load-config@4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)))(postcss@8.4.39)(sass@1.71.1)(svelte@4.2.7): + dependencies: + '@jridgewell/trace-mapping': 0.3.25 + chokidar: 3.6.0 + fast-glob: 3.3.2 + import-fresh: 3.3.0 + picocolors: 1.0.1 + sade: 1.8.1 + svelte: 4.2.7 + svelte-preprocess: 5.1.4(@babel/core@7.24.7)(less@4.2.0)(postcss-load-config@4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)))(postcss@8.4.39)(sass@1.71.1)(svelte@4.2.7)(typescript@5.5.3) + typescript: 5.5.3 + transitivePeerDependencies: + - '@babel/core' + - coffeescript + - less + - postcss + - postcss-load-config + - pug + - sass + - stylus + - sugarss + + svelte-eslint-parser@0.41.0(svelte@4.2.7): + dependencies: + eslint-scope: 7.2.2 + eslint-visitor-keys: 3.4.3 + espree: 9.6.1 + postcss: 8.4.39 + postcss-scss: 4.0.9(postcss@8.4.39) + optionalDependencies: + svelte: 4.2.7 + + svelte-hmr@0.15.3(svelte@4.2.7): + dependencies: + svelte: 4.2.7 + + svelte-preprocess@5.1.4(@babel/core@7.24.7)(less@4.2.0)(postcss-load-config@4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)))(postcss@8.4.39)(sass@1.71.1)(svelte@4.2.7)(typescript@5.5.3): + dependencies: + '@types/pug': 2.0.10 + detect-indent: 6.1.0 + magic-string: 0.30.10 + sorcery: 0.11.1 + strip-indent: 3.0.0 + svelte: 4.2.7 + optionalDependencies: + '@babel/core': 7.24.7 + less: 4.2.0 + postcss: 8.4.39 + postcss-load-config: 4.0.2(postcss@8.4.39)(ts-node@10.9.2(@types/node@20.14.10)(typescript@5.5.3)) + sass: 1.71.1 + typescript: 5.5.3 + + svelte@4.2.7: + dependencies: + '@ampproject/remapping': 2.3.0 + '@jridgewell/sourcemap-codec': 1.4.15 + '@jridgewell/trace-mapping': 0.3.25 + acorn: 8.12.0 + aria-query: 5.3.0 + axobject-query: 3.2.4 + code-red: 1.0.4 + css-tree: 2.3.1 + estree-walker: 3.0.3 + is-reference: 3.0.2 + locate-character: 3.0.0 + magic-string: 0.30.10 + periscopic: 3.1.0 + svg-tags@1.0.0: {} symbol-observable@4.0.0: {} @@ -14402,12 +15439,21 @@ snapshots: thunky@1.1.0: {} + tiny-glob@0.2.9: + dependencies: + globalyzer: 0.1.0 + globrex: 0.1.2 + tinybench@2.8.0: {} tinypool@0.8.4: {} + tinypool@1.0.0: {} + tinyspy@2.2.1: {} + tinyspy@3.0.0: {} + tmp@0.0.33: dependencies: os-tmpdir: 1.0.2 @@ -14508,6 +15554,17 @@ snapshots: transitivePeerDependencies: - supports-color + typescript-eslint@8.0.0(eslint@9.0.0)(typescript@5.5.3): + dependencies: + '@typescript-eslint/eslint-plugin': 8.0.0(@typescript-eslint/parser@8.0.0(eslint@9.0.0)(typescript@5.5.3))(eslint@9.0.0)(typescript@5.5.3) + '@typescript-eslint/parser': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + '@typescript-eslint/utils': 8.0.0(eslint@9.0.0)(typescript@5.5.3) + optionalDependencies: + typescript: 5.5.3 + transitivePeerDependencies: + - eslint + - supports-color + typescript@5.5.3: {} ufo@1.5.3: {} @@ -14638,6 +15695,23 @@ snapshots: - supports-color - terser + vite-node@2.0.0(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1): + dependencies: + cac: 6.7.14 + debug: 4.3.5 + pathe: 1.1.2 + picocolors: 1.0.1 + vite: 5.3.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + transitivePeerDependencies: + - '@types/node' + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser + vite-plugin-inspect@0.8.5(rollup@4.18.0)(vite@5.3.3(@types/node@20.14.5)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)): dependencies: '@antfu/utils': 0.7.10 @@ -14685,6 +15759,18 @@ snapshots: transitivePeerDependencies: - supports-color + vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1): + dependencies: + esbuild: 0.19.12 + postcss: 8.4.39 + rollup: 4.18.0 + optionalDependencies: + '@types/node': 20.14.10 + fsevents: 2.3.3 + less: 4.2.0 + sass: 1.71.1 + terser: 5.31.1 + vite@5.1.7(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.29.1): dependencies: esbuild: 0.19.12 @@ -14721,6 +15807,10 @@ snapshots: sass: 1.71.1 terser: 5.31.1 + vitefu@0.2.5(vite@5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1)): + optionalDependencies: + vite: 5.0.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + vitepress@1.3.0(@algolia/client-search@4.23.3)(@types/node@20.14.10)(@types/react@18.3.3)(axios@1.7.3)(less@4.2.0)(postcss@8.4.41)(react-dom@18.3.1(react@18.3.1))(react@18.3.1)(sass@1.71.1)(search-insights@2.14.0)(terser@5.31.1)(typescript@5.5.3): dependencies: '@docsearch/css': 3.6.0 @@ -14836,6 +15926,38 @@ snapshots: - supports-color - terser + vitest@2.0.0(@types/node@20.14.10)(jsdom@24.1.0)(less@4.2.0)(sass@1.71.1)(terser@5.31.1): + dependencies: + '@ampproject/remapping': 2.3.0 + '@vitest/expect': 2.0.0 + '@vitest/runner': 2.0.0 + '@vitest/snapshot': 2.0.0 + '@vitest/spy': 2.0.0 + '@vitest/utils': 2.0.0 + chai: 5.1.1 + debug: 4.3.5 + execa: 8.0.1 + magic-string: 0.30.10 + pathe: 1.1.2 + picocolors: 1.0.1 + std-env: 3.7.0 + tinybench: 2.8.0 + tinypool: 1.0.0 + vite: 5.3.3(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + vite-node: 2.0.0(@types/node@20.14.10)(less@4.2.0)(sass@1.71.1)(terser@5.31.1) + why-is-node-running: 2.3.0 + optionalDependencies: + '@types/node': 20.14.10 + jsdom: 24.1.0 + transitivePeerDependencies: + - less + - lightningcss + - sass + - stylus + - sugarss + - supports-color + - terser + vscode-uri@3.0.8: {} vue-component-type-helpers@2.0.29: {} @@ -15051,6 +16173,11 @@ snapshots: siginfo: 2.0.0 stackback: 0.0.2 + why-is-node-running@2.3.0: + dependencies: + siginfo: 2.0.0 + stackback: 0.0.2 + wildcard@2.0.1: {} word-wrap@1.2.5: {} @@ -15099,6 +16226,8 @@ snapshots: yallist@4.0.0: {} + yaml@1.10.2: {} + yaml@2.4.5: {} yargs-parser@21.1.1: {}

}aQ)I{G+bi^-b>dvszISW^+;_HZ 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 K9Cw|u00RI=HQoRK literal 0 HcmV?d00001 diff --git a/examples/openapi-ts-tanstack-svelte-query/src/routes/+layout.svelte b/examples/openapi-ts-tanstack-svelte-query/src/routes/+layout.svelte new file mode 100644 index 000000000..bc851e084 --- /dev/null +++ b/examples/openapi-ts-tanstack-svelte-query/src/routes/+layout.svelte @@ -0,0 +1,77 @@ + + +