+5

.changeset/ninety-windows-accept.md

··· 1 1 + --- 2 2 + '@hey-api/openapi-ts': patch 3 3 + --- 4 4 + 5 5 + fix: handle tree-shakeable angular client case

+1

packages/openapi-ts/src/compiler/index.ts

··· 168 168 } 169 169 170 170 export const compiler = { 171 171 + anonymousFunction: types.createAnonymousFunction, 171 172 arrayLiteralExpression: types.createArrayLiteralExpression, 172 173 arrowFunction: types.createArrowFunction, 173 174 awaitExpression: types.createAwaitExpression,

+38

packages/openapi-ts/src/compiler/types.ts

··· 299 299 }; 300 300 301 301 /** 302 302 + * Create anonymous function type expression. 303 303 + */ 304 304 + export const createAnonymousFunction = ({ 305 305 + async, 306 306 + comment, 307 307 + multiLine, 308 308 + parameters = [], 309 309 + returnType, 310 310 + statements = [], 311 311 + types = [], 312 312 + }: { 313 313 + async?: boolean; 314 314 + comment?: Comments; 315 315 + multiLine?: boolean; 316 316 + parameters?: FunctionParameter[]; 317 317 + returnType?: string | ts.TypeNode; 318 318 + statements?: ts.Statement[]; 319 319 + types?: FunctionTypeParameter[]; 320 320 + }) => { 321 321 + const expression = ts.factory.createFunctionExpression( 322 322 + async ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)] : undefined, 323 323 + undefined, 324 324 + undefined, 325 325 + types ? toTypeParameters(types) : undefined, 326 326 + toParameterDeclarations(parameters), 327 327 + returnType ? createTypeNode(returnType) : undefined, 328 328 + ts.factory.createBlock(statements, multiLine), 329 329 + ); 330 330 + 331 331 + addLeadingComments({ 332 332 + comments: comment, 333 333 + node: expression, 334 334 + }); 335 335 + 336 336 + return expression; 337 337 + }; 338 338 + 339 339 + /** 302 340 * Create Array type expression. 303 341 * @param arr - The array to create. 304 342 * @param multiLine - if the array should be multiline.

+6 -2

packages/openapi-ts/src/generate/services.ts

··· 610 610 611 611 if (!config.services.asClass && !config.name) { 612 612 for (const operation of service.operations) { 613 613 - const expression = compiler.arrowFunction({ 613 613 + const compileFunctionParams = { 614 614 parameters: toOperationParamType(client, operation), 615 615 returnType: isStandalone 616 616 ? undefined ··· 622 622 onClientImport, 623 623 ), 624 624 types: isStandalone ? [throwOnErrorTypeGeneric] : undefined, 625 625 - }); 625 625 + }; 626 626 + const expression = 627 627 + config.client.name === 'angular' 628 628 + ? compiler.anonymousFunction(compileFunctionParams) 629 629 + : compiler.arrowFunction(compileFunctionParams); 626 630 const statement = compiler.constVariable({ 627 631 comment: toOperationComment(operation), 628 632 exportConst: true,

+21

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/core/ApiError.ts.snap

··· 1 1 + import type { ApiRequestOptions } from './ApiRequestOptions'; 2 2 + import type { ApiResult } from './ApiResult'; 3 3 + 4 4 + export class ApiError extends Error { 5 5 + public readonly url: string; 6 6 + public readonly status: number; 7 7 + public readonly statusText: string; 8 8 + public readonly body: unknown; 9 9 + public readonly request: ApiRequestOptions; 10 10 + 11 11 + constructor(request: ApiRequestOptions, response: ApiResult, message: string) { 12 12 + super(message); 13 13 + 14 14 + this.name = 'ApiError'; 15 15 + this.url = response.url; 16 16 + this.status = response.status; 17 17 + this.statusText = response.statusText; 18 18 + this.body = response.body; 19 19 + this.request = request; 20 20 + } 21 21 + }

+21

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/core/ApiRequestOptions.ts.snap

··· 1 1 + export type ApiRequestOptions<T = unknown> = { 2 2 + readonly body?: any; 3 3 + readonly cookies?: Record<string, unknown>; 4 4 + readonly errors?: Record<number | string, string>; 5 5 + readonly formData?: Record<string, unknown> | any[] | Blob | File; 6 6 + readonly headers?: Record<string, unknown>; 7 7 + readonly mediaType?: string; 8 8 + readonly method: 9 9 + | 'DELETE' 10 10 + | 'GET' 11 11 + | 'HEAD' 12 12 + | 'OPTIONS' 13 13 + | 'PATCH' 14 14 + | 'POST' 15 15 + | 'PUT'; 16 16 + readonly path?: Record<string, unknown>; 17 17 + readonly query?: Record<string, unknown>; 18 18 + readonly responseHeader?: string; 19 19 + readonly responseTransformer?: (data: unknown) => Promise<T>; 20 20 + readonly url: string; 21 21 + };

+7

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/core/ApiResult.ts.snap

··· 1 1 + export type ApiResult<TData = any> = { 2 2 + readonly body: TData; 3 3 + readonly ok: boolean; 4 4 + readonly status: number; 5 5 + readonly statusText: string; 6 6 + readonly url: string; 7 7 + };

+55

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/core/OpenAPI.ts.snap

··· 1 1 + import type { HttpResponse } from '@angular/common/http'; 2 2 + import type { ApiRequestOptions } from './ApiRequestOptions'; 3 3 + 4 4 + type Headers = Record<string, string>; 5 5 + type Middleware<T> = (value: T) => T | Promise<T>; 6 6 + type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>; 7 7 + 8 8 + export class Interceptors<T> { 9 9 + _fns: Middleware<T>[]; 10 10 + 11 11 + constructor() { 12 12 + this._fns = []; 13 13 + } 14 14 + 15 15 + eject(fn: Middleware<T>): void { 16 16 + const index = this._fns.indexOf(fn); 17 17 + if (index !== -1) { 18 18 + this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)]; 19 19 + } 20 20 + } 21 21 + 22 22 + use(fn: Middleware<T>): void { 23 23 + this._fns = [...this._fns, fn]; 24 24 + } 25 25 + } 26 26 + 27 27 + export type OpenAPIConfig = { 28 28 + BASE: string; 29 29 + CREDENTIALS: 'include' | 'omit' | 'same-origin'; 30 30 + ENCODE_PATH?: ((path: string) => string) | undefined; 31 31 + HEADERS?: Headers | Resolver<Headers> | undefined; 32 32 + PASSWORD?: string | Resolver<string> | undefined; 33 33 + TOKEN?: string | Resolver<string> | undefined; 34 34 + USERNAME?: string | Resolver<string> | undefined; 35 35 + VERSION: string; 36 36 + WITH_CREDENTIALS: boolean; 37 37 + interceptors: { 38 38 + response: Interceptors<HttpResponse<any>>; 39 39 + }; 40 40 + }; 41 41 + 42 42 + export const OpenAPI: OpenAPIConfig = { 43 43 + BASE: 'http://localhost:3000/base', 44 44 + CREDENTIALS: 'include', 45 45 + ENCODE_PATH: undefined, 46 46 + HEADERS: undefined, 47 47 + PASSWORD: undefined, 48 48 + TOKEN: undefined, 49 49 + USERNAME: undefined, 50 50 + VERSION: '1.0', 51 51 + WITH_CREDENTIALS: false, 52 52 + interceptors: { 53 53 + response: new Interceptors(), 54 54 + }, 55 55 + };

+337

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/core/request.ts.snap

··· 1 1 + import { HttpClient, HttpHeaders } from '@angular/common/http'; 2 2 + import type { HttpResponse, HttpErrorResponse } from '@angular/common/http'; 3 3 + import { forkJoin, of, throwError } from 'rxjs'; 4 4 + import { catchError, map, switchMap } from 'rxjs/operators'; 5 5 + import type { Observable } from 'rxjs'; 6 6 + 7 7 + import { ApiError } from './ApiError'; 8 8 + import type { ApiRequestOptions } from './ApiRequestOptions'; 9 9 + import type { ApiResult } from './ApiResult'; 10 10 + import type { OpenAPIConfig } from './OpenAPI'; 11 11 + 12 12 + export const isString = (value: unknown): value is string => { 13 13 + return typeof value === 'string'; 14 14 + }; 15 15 + 16 16 + export const isStringWithValue = (value: unknown): value is string => { 17 17 + return isString(value) && value !== ''; 18 18 + }; 19 19 + 20 20 + export const isBlob = (value: any): value is Blob => { 21 21 + return value instanceof Blob; 22 22 + }; 23 23 + 24 24 + export const isFormData = (value: unknown): value is FormData => { 25 25 + return value instanceof FormData; 26 26 + }; 27 27 + 28 28 + export const base64 = (str: string): string => { 29 29 + try { 30 30 + return btoa(str); 31 31 + } catch (err) { 32 32 + // @ts-ignore 33 33 + return Buffer.from(str).toString('base64'); 34 34 + } 35 35 + }; 36 36 + 37 37 + export const getQueryString = (params: Record<string, unknown>): string => { 38 38 + const qs: string[] = []; 39 39 + 40 40 + const append = (key: string, value: unknown) => { 41 41 + qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`); 42 42 + }; 43 43 + 44 44 + const encodePair = (key: string, value: unknown) => { 45 45 + if (value === undefined || value === null) { 46 46 + return; 47 47 + } 48 48 + 49 49 + if (value instanceof Date) { 50 50 + append(key, value.toISOString()); 51 51 + } else if (Array.isArray(value)) { 52 52 + value.forEach(v => encodePair(key, v)); 53 53 + } else if (typeof value === 'object') { 54 54 + Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v)); 55 55 + } else { 56 56 + append(key, value); 57 57 + } 58 58 + }; 59 59 + 60 60 + Object.entries(params).forEach(([key, value]) => encodePair(key, value)); 61 61 + 62 62 + return qs.length ? `?${qs.join('&')}` : ''; 63 63 + }; 64 64 + 65 65 + const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { 66 66 + const encoder = config.ENCODE_PATH || encodeURI; 67 67 + 68 68 + const path = options.url 69 69 + .replace('{api-version}', config.VERSION) 70 70 + .replace(/{(.*?)}/g, (substring: string, group: string) => { 71 71 + if (options.path?.hasOwnProperty(group)) { 72 72 + return encoder(String(options.path[group])); 73 73 + } 74 74 + return substring; 75 75 + }); 76 76 + 77 77 + const url = config.BASE + path; 78 78 + return options.query ? url + getQueryString(options.query) : url; 79 79 + }; 80 80 + 81 81 + export const getFormData = (options: ApiRequestOptions): FormData | undefined => { 82 82 + if (options.formData) { 83 83 + const formData = new FormData(); 84 84 + 85 85 + const process = (key: string, value: unknown) => { 86 86 + if (isString(value) || isBlob(value)) { 87 87 + formData.append(key, value); 88 88 + } else { 89 89 + formData.append(key, JSON.stringify(value)); 90 90 + } 91 91 + }; 92 92 + 93 93 + Object.entries(options.formData) 94 94 + .filter(([, value]) => value !== undefined && value !== null) 95 95 + .forEach(([key, value]) => { 96 96 + if (Array.isArray(value)) { 97 97 + value.forEach(v => process(key, v)); 98 98 + } else { 99 99 + process(key, value); 100 100 + } 101 101 + }); 102 102 + 103 103 + return formData; 104 104 + } 105 105 + return undefined; 106 106 + }; 107 107 + 108 108 + type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>; 109 109 + 110 110 + export const resolve = async <T>(options: ApiRequestOptions<T>, resolver?: T | Resolver<T>): Promise<T | undefined> => { 111 111 + if (typeof resolver === 'function') { 112 112 + return (resolver as Resolver<T>)(options); 113 113 + } 114 114 + return resolver; 115 115 + }; 116 116 + 117 117 + export const getHeaders = <T>(config: OpenAPIConfig, options: ApiRequestOptions<T>): Observable<HttpHeaders> => { 118 118 + return forkJoin({ 119 119 + // @ts-ignore 120 120 + token: resolve(options, config.TOKEN), 121 121 + // @ts-ignore 122 122 + username: resolve(options, config.USERNAME), 123 123 + // @ts-ignore 124 124 + password: resolve(options, config.PASSWORD), 125 125 + // @ts-ignore 126 126 + additionalHeaders: resolve(options, config.HEADERS), 127 127 + }).pipe( 128 128 + map(({ token, username, password, additionalHeaders }) => { 129 129 + const headers = Object.entries({ 130 130 + Accept: 'application/json', 131 131 + ...additionalHeaders, 132 132 + ...options.headers, 133 133 + }) 134 134 + .filter(([, value]) => value !== undefined && value !== null) 135 135 + .reduce((headers, [key, value]) => ({ 136 136 + ...headers, 137 137 + [key]: String(value), 138 138 + }), {} as Record<string, string>); 139 139 + 140 140 + if (isStringWithValue(token)) { 141 141 + headers['Authorization'] = `Bearer ${token}`; 142 142 + } 143 143 + 144 144 + if (isStringWithValue(username) && isStringWithValue(password)) { 145 145 + const credentials = base64(`${username}:${password}`); 146 146 + headers['Authorization'] = `Basic ${credentials}`; 147 147 + } 148 148 + 149 149 + if (options.body !== undefined) { 150 150 + if (options.mediaType) { 151 151 + headers['Content-Type'] = options.mediaType; 152 152 + } else if (isBlob(options.body)) { 153 153 + headers['Content-Type'] = options.body.type || 'application/octet-stream'; 154 154 + } else if (isString(options.body)) { 155 155 + headers['Content-Type'] = 'text/plain'; 156 156 + } else if (!isFormData(options.body)) { 157 157 + headers['Content-Type'] = 'application/json'; 158 158 + } 159 159 + } 160 160 + 161 161 + return new HttpHeaders(headers); 162 162 + }), 163 163 + ); 164 164 + }; 165 165 + 166 166 + export const getRequestBody = (options: ApiRequestOptions): unknown => { 167 167 + if (options.body) { 168 168 + if (options.mediaType?.includes('application/json') || options.mediaType?.includes('+json')) { 169 169 + return JSON.stringify(options.body); 170 170 + } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { 171 171 + return options.body; 172 172 + } else { 173 173 + return JSON.stringify(options.body); 174 174 + } 175 175 + } 176 176 + return undefined; 177 177 + }; 178 178 + 179 179 + export const sendRequest = <T>( 180 180 + config: OpenAPIConfig, 181 181 + options: ApiRequestOptions<T>, 182 182 + http: HttpClient, 183 183 + url: string, 184 184 + body: unknown, 185 185 + formData: FormData | undefined, 186 186 + headers: HttpHeaders 187 187 + ): Observable<HttpResponse<T>> => { 188 188 + return http.request<T>(options.method, url, { 189 189 + headers, 190 190 + body: body ?? formData, 191 191 + withCredentials: config.WITH_CREDENTIALS, 192 192 + observe: 'response', 193 193 + }); 194 194 + }; 195 195 + 196 196 + export const getResponseHeader = <T>(response: HttpResponse<T>, responseHeader?: string): string | undefined => { 197 197 + if (responseHeader) { 198 198 + const value = response.headers.get(responseHeader); 199 199 + if (isString(value)) { 200 200 + return value; 201 201 + } 202 202 + } 203 203 + return undefined; 204 204 + }; 205 205 + 206 206 + export const getResponseBody = <T>(response: HttpResponse<T>): T | undefined => { 207 207 + if (response.status !== 204 && response.body !== null) { 208 208 + return response.body; 209 209 + } 210 210 + return undefined; 211 211 + }; 212 212 + 213 213 + export const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult): void => { 214 214 + const errors: Record<number, string> = { 215 215 + 400: 'Bad Request', 216 216 + 401: 'Unauthorized', 217 217 + 402: 'Payment Required', 218 218 + 403: 'Forbidden', 219 219 + 404: 'Not Found', 220 220 + 405: 'Method Not Allowed', 221 221 + 406: 'Not Acceptable', 222 222 + 407: 'Proxy Authentication Required', 223 223 + 408: 'Request Timeout', 224 224 + 409: 'Conflict', 225 225 + 410: 'Gone', 226 226 + 411: 'Length Required', 227 227 + 412: 'Precondition Failed', 228 228 + 413: 'Payload Too Large', 229 229 + 414: 'URI Too Long', 230 230 + 415: 'Unsupported Media Type', 231 231 + 416: 'Range Not Satisfiable', 232 232 + 417: 'Expectation Failed', 233 233 + 418: 'Im a teapot', 234 234 + 421: 'Misdirected Request', 235 235 + 422: 'Unprocessable Content', 236 236 + 423: 'Locked', 237 237 + 424: 'Failed Dependency', 238 238 + 425: 'Too Early', 239 239 + 426: 'Upgrade Required', 240 240 + 428: 'Precondition Required', 241 241 + 429: 'Too Many Requests', 242 242 + 431: 'Request Header Fields Too Large', 243 243 + 451: 'Unavailable For Legal Reasons', 244 244 + 500: 'Internal Server Error', 245 245 + 501: 'Not Implemented', 246 246 + 502: 'Bad Gateway', 247 247 + 503: 'Service Unavailable', 248 248 + 504: 'Gateway Timeout', 249 249 + 505: 'HTTP Version Not Supported', 250 250 + 506: 'Variant Also Negotiates', 251 251 + 507: 'Insufficient Storage', 252 252 + 508: 'Loop Detected', 253 253 + 510: 'Not Extended', 254 254 + 511: 'Network Authentication Required', 255 255 + ...options.errors, 256 256 + } 257 257 + 258 258 + const error = errors[result.status]; 259 259 + if (error) { 260 260 + throw new ApiError(options, result, error); 261 261 + } 262 262 + 263 263 + if (!result.ok) { 264 264 + const errorStatus = result.status ?? 'unknown'; 265 265 + const errorStatusText = result.statusText ?? 'unknown'; 266 266 + const errorBody = (() => { 267 267 + try { 268 268 + return JSON.stringify(result.body, null, 2); 269 269 + } catch (e) { 270 270 + return undefined; 271 271 + } 272 272 + })(); 273 273 + 274 274 + throw new ApiError(options, result, 275 275 + `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}` 276 276 + ); 277 277 + } 278 278 + }; 279 279 + 280 280 + /** 281 281 + * Request method 282 282 + * @param config The OpenAPI configuration object 283 283 + * @param http The Angular HTTP client 284 284 + * @param options The request options from the service 285 285 + * @returns Observable<T> 286 286 + * @throws ApiError 287 287 + */ 288 288 + export const request = <T>(config: OpenAPIConfig, http: HttpClient, options: ApiRequestOptions<T>): Observable<T> => { 289 289 + const url = getUrl(config, options); 290 290 + const formData = getFormData(options); 291 291 + const body = getRequestBody(options); 292 292 + 293 293 + return getHeaders(config, options).pipe( 294 294 + switchMap(headers => { 295 295 + return sendRequest<T>(config, options, http, url, body, formData, headers); 296 296 + }), 297 297 + switchMap(async response => { 298 298 + for (const fn of config.interceptors.response._fns) { 299 299 + response = await fn(response); 300 300 + } 301 301 + const responseBody = getResponseBody(response); 302 302 + const responseHeader = getResponseHeader(response, options.responseHeader); 303 303 + 304 304 + let transformedBody = responseBody; 305 305 + if (options.responseTransformer && response.ok) { 306 306 + transformedBody = await options.responseTransformer(responseBody) 307 307 + } 308 308 + 309 309 + return { 310 310 + url, 311 311 + ok: response.ok, 312 312 + status: response.status, 313 313 + statusText: response.statusText, 314 314 + body: responseHeader ?? transformedBody, 315 315 + } as ApiResult; 316 316 + }), 317 317 + catchError((error: HttpErrorResponse) => { 318 318 + if (!error.status) { 319 319 + return throwError(() => error); 320 320 + } 321 321 + return of({ 322 322 + url, 323 323 + ok: error.ok, 324 324 + status: error.status, 325 325 + statusText: error.statusText, 326 326 + body: error.error ?? error.statusText, 327 327 + } as ApiResult); 328 328 + }), 329 329 + map(result => { 330 330 + catchErrorCodes(options, result); 331 331 + return result.body as T; 332 332 + }), 333 333 + catchError((error: ApiError) => { 334 334 + return throwError(() => error); 335 335 + }), 336 336 + ); 337 337 + };

+5

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/index.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + export { ApiError } from './core/ApiError'; 3 3 + export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI'; 4 4 + export * from './services.gen'; 5 5 + export * from './types.gen';

+668

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/services.gen.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + 3 3 + import { Injectable } from '@angular/core'; 4 4 + import { HttpClient } from '@angular/common/http'; 5 5 + import type { Observable } from 'rxjs'; 6 6 + import { OpenAPI } from './core/OpenAPI'; 7 7 + import { request as __request } from './core/request'; 8 8 + import type { ImportData, ImportResponse, ApiVversionOdataControllerCountResponse, DeleteFooData3, CallWithDescriptionsData, DeprecatedCallData, CallWithParametersData, CallWithWeirdParameterNamesData, GetCallWithOptionalParamData, PostCallWithOptionalParamData, PostCallWithOptionalParamResponse, PostApiRequestBodyData, PostApiFormDataData, CallWithDefaultParametersData, CallWithDefaultOptionalParametersData, CallToTestOrderOfParamsData, CallWithNoContentResponseResponse, CallWithResponseAndNoContentResponseResponse, DummyAResponse, DummyBResponse, CallWithResponseResponse, CallWithDuplicateResponsesResponse, CallWithResponsesResponse, CollectionFormatData, TypesData, TypesResponse, UploadFileData, UploadFileResponse, FileResponseData, FileResponseResponse, ComplexTypesData, ComplexTypesResponse, MultipartRequestData, MultipartResponseResponse, ComplexParamsData, ComplexParamsResponse, CallWithResultFromHeaderResponse, TestErrorCodeData, TestErrorCodeResponse, NonAsciiæøåÆøÅöôêÊ字符串Data, NonAsciiæøåÆøÅöôêÊ字符串Response, PutWithFormUrlEncodedData } from './types.gen'; 9 9 + 10 10 + /** 11 11 + * @throws ApiError 12 12 + */ 13 13 + export const export_ = function (): Observable<void> { return __request(OpenAPI, this.http, { 14 14 + method: 'GET', 15 15 + url: '/api/v{api-version}/no-tag' 16 16 + }); }; 17 17 + 18 18 + /** 19 19 + * @param data The data for the request. 20 20 + * @param data.requestBody 21 21 + * @returns Model_From_Zendesk Success 22 22 + * @returns ModelWithReadOnlyAndWriteOnly Default success response 23 23 + * @throws ApiError 24 24 + */ 25 25 + export const import_ = function (data: ImportData): Observable<ImportResponse> { return __request(OpenAPI, this.http, { 26 26 + method: 'POST', 27 27 + url: '/api/v{api-version}/no-tag', 28 28 + body: data.requestBody, 29 29 + mediaType: 'application/json' 30 30 + }); }; 31 31 + 32 32 + /** 33 33 + * @returns Model_From_Zendesk Success 34 34 + * @throws ApiError 35 35 + */ 36 36 + export const apiVVersionOdataControllerCount = function (): Observable<ApiVversionOdataControllerCountResponse> { return __request(OpenAPI, this.http, { 37 37 + method: 'GET', 38 38 + url: '/api/v{api-version}/simple/$count' 39 39 + }); }; 40 40 + 41 41 + /** 42 42 + * @throws ApiError 43 43 + */ 44 44 + export const getCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 45 45 + method: 'GET', 46 46 + url: '/api/v{api-version}/simple' 47 47 + }); }; 48 48 + 49 49 + /** 50 50 + * @throws ApiError 51 51 + */ 52 52 + export const putCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 53 53 + method: 'PUT', 54 54 + url: '/api/v{api-version}/simple' 55 55 + }); }; 56 56 + 57 57 + /** 58 58 + * @throws ApiError 59 59 + */ 60 60 + export const postCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 61 61 + method: 'POST', 62 62 + url: '/api/v{api-version}/simple' 63 63 + }); }; 64 64 + 65 65 + /** 66 66 + * @throws ApiError 67 67 + */ 68 68 + export const deleteCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 69 69 + method: 'DELETE', 70 70 + url: '/api/v{api-version}/simple' 71 71 + }); }; 72 72 + 73 73 + /** 74 74 + * @throws ApiError 75 75 + */ 76 76 + export const optionsCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 77 77 + method: 'OPTIONS', 78 78 + url: '/api/v{api-version}/simple' 79 79 + }); }; 80 80 + 81 81 + /** 82 82 + * @throws ApiError 83 83 + */ 84 84 + export const headCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 85 85 + method: 'HEAD', 86 86 + url: '/api/v{api-version}/simple' 87 87 + }); }; 88 88 + 89 89 + /** 90 90 + * @throws ApiError 91 91 + */ 92 92 + export const patchCallWithoutParametersAndResponse = function (): Observable<void> { return __request(OpenAPI, this.http, { 93 93 + method: 'PATCH', 94 94 + url: '/api/v{api-version}/simple' 95 95 + }); }; 96 96 + 97 97 + /** 98 98 + * @param data The data for the request. 99 99 + * @param data.fooParam foo in method 100 100 + * @param data.barParam bar in method 101 101 + * @param data.xFooBar Parameter with illegal characters 102 102 + * @throws ApiError 103 103 + */ 104 104 + export const deleteFoo = function (data: DeleteFooData3): Observable<void> { return __request(OpenAPI, this.http, { 105 105 + method: 'DELETE', 106 106 + url: '/api/v{api-version}/foo/{foo_param}/bar/{BarParam}', 107 107 + path: { 108 108 + foo_param: data.fooParam, 109 109 + BarParam: data.barParam 110 110 + }, 111 111 + headers: { 112 112 + 'x-Foo-Bar': data.xFooBar 113 113 + } 114 114 + }); }; 115 115 + 116 116 + /** 117 117 + * @param data The data for the request. 118 118 + * @param data.parameterWithBreaks Testing multiline comments in string: First line 119 119 + * Second line 120 120 + * 121 121 + * Fourth line 122 122 + * @param data.parameterWithBackticks Testing backticks in string: `backticks` and ```multiple backticks``` should work 123 123 + * @param data.parameterWithSlashes Testing slashes in string: \backwards\\\ and /forwards/// should work 124 124 + * @param data.parameterWithExpressionPlaceholders Testing expression placeholders in string: ${expression} should work 125 125 + * @param data.parameterWithQuotes Testing quotes in string: 'single quote''' and "double quotes""" should work 126 126 + * @param data.parameterWithReservedCharacters Testing reserved characters in string: * inline * and ** inline ** should work 127 127 + * @throws ApiError 128 128 + */ 129 129 + export const callWithDescriptions = function (data: CallWithDescriptionsData = {}): Observable<void> { return __request(OpenAPI, this.http, { 130 130 + method: 'POST', 131 131 + url: '/api/v{api-version}/descriptions/', 132 132 + query: { 133 133 + parameterWithBreaks: data.parameterWithBreaks, 134 134 + parameterWithBackticks: data.parameterWithBackticks, 135 135 + parameterWithSlashes: data.parameterWithSlashes, 136 136 + parameterWithExpressionPlaceholders: data.parameterWithExpressionPlaceholders, 137 137 + parameterWithQuotes: data.parameterWithQuotes, 138 138 + parameterWithReservedCharacters: data.parameterWithReservedCharacters 139 139 + } 140 140 + }); }; 141 141 + 142 142 + /** 143 143 + * @deprecated 144 144 + * @param data The data for the request. 145 145 + * @param data.parameter This parameter is deprecated 146 146 + * @throws ApiError 147 147 + */ 148 148 + export const deprecatedCall = function (data: DeprecatedCallData): Observable<void> { return __request(OpenAPI, this.http, { 149 149 + method: 'POST', 150 150 + url: '/api/v{api-version}/parameters/deprecated', 151 151 + headers: { 152 152 + parameter: data.parameter 153 153 + } 154 154 + }); }; 155 155 + 156 156 + /** 157 157 + * @param data The data for the request. 158 158 + * @param data.parameterHeader This is the parameter that goes into the header 159 159 + * @param data.fooAllOfEnum 160 160 + * @param data.cursor This is the parameter that goes into the query params 161 161 + * @param data.parameterCookie This is the parameter that goes into the cookie 162 162 + * @param data.parameterPath This is the parameter that goes into the path 163 163 + * @param data.requestBody This is the parameter that goes into the body 164 164 + * @param data.fooRefEnum 165 165 + * @throws ApiError 166 166 + */ 167 167 + export const callWithParameters = function (data: CallWithParametersData): Observable<void> { return __request(OpenAPI, this.http, { 168 168 + method: 'POST', 169 169 + url: '/api/v{api-version}/parameters/{parameterPath}', 170 170 + path: { 171 171 + parameterPath: data.parameterPath 172 172 + }, 173 173 + cookies: { 174 174 + parameterCookie: data.parameterCookie 175 175 + }, 176 176 + headers: { 177 177 + parameterHeader: data.parameterHeader 178 178 + }, 179 179 + query: { 180 180 + foo_ref_enum: data.fooRefEnum, 181 181 + foo_all_of_enum: data.fooAllOfEnum, 182 182 + cursor: data.cursor 183 183 + }, 184 184 + body: data.requestBody, 185 185 + mediaType: 'application/json' 186 186 + }); }; 187 187 + 188 188 + /** 189 189 + * @param data The data for the request. 190 190 + * @param data.parameterHeader This is the parameter that goes into the request header 191 191 + * @param data.parameterQuery This is the parameter that goes into the request query params 192 192 + * @param data.parameterCookie This is the parameter that goes into the cookie 193 193 + * @param data.requestBody This is the parameter that goes into the body 194 194 + * @param data.parameterPath1 This is the parameter that goes into the path 195 195 + * @param data.parameterPath2 This is the parameter that goes into the path 196 196 + * @param data.parameterPath3 This is the parameter that goes into the path 197 197 + * @param data._default This is the parameter with a reserved keyword 198 198 + * @throws ApiError 199 199 + */ 200 200 + export const callWithWeirdParameterNames = function (data: CallWithWeirdParameterNamesData): Observable<void> { return __request(OpenAPI, this.http, { 201 201 + method: 'POST', 202 202 + url: '/api/v{api-version}/parameters/{parameter.path.1}/{parameter-path-2}/{PARAMETER-PATH-3}', 203 203 + path: { 204 204 + 'parameter.path.1': data.parameterPath1, 205 205 + 'parameter-path-2': data.parameterPath2, 206 206 + 'PARAMETER-PATH-3': data.parameterPath3 207 207 + }, 208 208 + cookies: { 209 209 + 'PARAMETER-COOKIE': data.parameterCookie 210 210 + }, 211 211 + headers: { 212 212 + 'parameter.header': data.parameterHeader 213 213 + }, 214 214 + query: { 215 215 + default: data._default, 216 216 + 'parameter-query': data.parameterQuery 217 217 + }, 218 218 + body: data.requestBody, 219 219 + mediaType: 'application/json' 220 220 + }); }; 221 221 + 222 222 + /** 223 223 + * @param data The data for the request. 224 224 + * @param data.requestBody This is a required parameter 225 225 + * @param data.page This is an optional parameter 226 226 + * @throws ApiError 227 227 + */ 228 228 + export const getCallWithOptionalParam = function (data: GetCallWithOptionalParamData): Observable<void> { return __request(OpenAPI, this.http, { 229 229 + method: 'GET', 230 230 + url: '/api/v{api-version}/parameters/', 231 231 + query: { 232 232 + page: data.page 233 233 + }, 234 234 + body: data.requestBody, 235 235 + mediaType: 'application/json' 236 236 + }); }; 237 237 + 238 238 + /** 239 239 + * @param data The data for the request. 240 240 + * @param data.parameter This is a required parameter 241 241 + * @param data.requestBody This is an optional parameter 242 242 + * @returns number Response is a simple number 243 243 + * @returns void Success 244 244 + * @throws ApiError 245 245 + */ 246 246 + export const postCallWithOptionalParam = function (data: PostCallWithOptionalParamData): Observable<PostCallWithOptionalParamResponse> { return __request(OpenAPI, this.http, { 247 247 + method: 'POST', 248 248 + url: '/api/v{api-version}/parameters/', 249 249 + query: { 250 250 + parameter: data.parameter 251 251 + }, 252 252 + body: data.requestBody, 253 253 + mediaType: 'application/json' 254 254 + }); }; 255 255 + 256 256 + /** 257 257 + * @param data The data for the request. 258 258 + * @param data.parameter This is a reusable parameter 259 259 + * @param data.foo A reusable request body 260 260 + * @throws ApiError 261 261 + */ 262 262 + export const postApiRequestBody = function (data: PostApiRequestBodyData = {}): Observable<void> { return __request(OpenAPI, this.http, { 263 263 + method: 'POST', 264 264 + url: '/api/v{api-version}/requestBody/', 265 265 + query: { 266 266 + parameter: data.parameter 267 267 + }, 268 268 + body: data.foo, 269 269 + mediaType: 'application/json' 270 270 + }); }; 271 271 + 272 272 + /** 273 273 + * @param data The data for the request. 274 274 + * @param data.parameter This is a reusable parameter 275 275 + * @param data.formData A reusable request body 276 276 + * @throws ApiError 277 277 + */ 278 278 + export const postApiFormData = function (data: PostApiFormDataData = {}): Observable<void> { return __request(OpenAPI, this.http, { 279 279 + method: 'POST', 280 280 + url: '/api/v{api-version}/formData/', 281 281 + query: { 282 282 + parameter: data.parameter 283 283 + }, 284 284 + formData: data.formData, 285 285 + mediaType: 'multipart/form-data' 286 286 + }); }; 287 287 + 288 288 + /** 289 289 + * @param data The data for the request. 290 290 + * @param data.parameterString This is a simple string with default value 291 291 + * @param data.parameterNumber This is a simple number with default value 292 292 + * @param data.parameterBoolean This is a simple boolean with default value 293 293 + * @param data.parameterEnum This is a simple enum with default value 294 294 + * @param data.parameterModel This is a simple model with default value 295 295 + * @throws ApiError 296 296 + */ 297 297 + export const callWithDefaultParameters = function (data: CallWithDefaultParametersData = {}): Observable<void> { return __request(OpenAPI, this.http, { 298 298 + method: 'GET', 299 299 + url: '/api/v{api-version}/defaults', 300 300 + query: { 301 301 + parameterString: data.parameterString, 302 302 + parameterNumber: data.parameterNumber, 303 303 + parameterBoolean: data.parameterBoolean, 304 304 + parameterEnum: data.parameterEnum, 305 305 + parameterModel: data.parameterModel 306 306 + } 307 307 + }); }; 308 308 + 309 309 + /** 310 310 + * @param data The data for the request. 311 311 + * @param data.parameterString This is a simple string that is optional with default value 312 312 + * @param data.parameterNumber This is a simple number that is optional with default value 313 313 + * @param data.parameterBoolean This is a simple boolean that is optional with default value 314 314 + * @param data.parameterEnum This is a simple enum that is optional with default value 315 315 + * @param data.parameterModel This is a simple model that is optional with default value 316 316 + * @throws ApiError 317 317 + */ 318 318 + export const callWithDefaultOptionalParameters = function (data: CallWithDefaultOptionalParametersData = {}): Observable<void> { return __request(OpenAPI, this.http, { 319 319 + method: 'POST', 320 320 + url: '/api/v{api-version}/defaults', 321 321 + query: { 322 322 + parameterString: data.parameterString, 323 323 + parameterNumber: data.parameterNumber, 324 324 + parameterBoolean: data.parameterBoolean, 325 325 + parameterEnum: data.parameterEnum, 326 326 + parameterModel: data.parameterModel 327 327 + } 328 328 + }); }; 329 329 + 330 330 + /** 331 331 + * @param data The data for the request. 332 332 + * @param data.parameterStringWithNoDefault This is a string with no default 333 333 + * @param data.parameterOptionalStringWithDefault This is a optional string with default 334 334 + * @param data.parameterOptionalStringWithEmptyDefault This is a optional string with empty default 335 335 + * @param data.parameterOptionalStringWithNoDefault This is a optional string with no default 336 336 + * @param data.parameterStringWithDefault This is a string with default 337 337 + * @param data.parameterStringWithEmptyDefault This is a string with empty default 338 338 + * @param data.parameterStringNullableWithNoDefault This is a string that can be null with no default 339 339 + * @param data.parameterStringNullableWithDefault This is a string that can be null with default 340 340 + * @throws ApiError 341 341 + */ 342 342 + export const callToTestOrderOfParams = function (data: CallToTestOrderOfParamsData): Observable<void> { return __request(OpenAPI, this.http, { 343 343 + method: 'PUT', 344 344 + url: '/api/v{api-version}/defaults', 345 345 + query: { 346 346 + parameterOptionalStringWithDefault: data.parameterOptionalStringWithDefault, 347 347 + parameterOptionalStringWithEmptyDefault: data.parameterOptionalStringWithEmptyDefault, 348 348 + parameterOptionalStringWithNoDefault: data.parameterOptionalStringWithNoDefault, 349 349 + parameterStringWithDefault: data.parameterStringWithDefault, 350 350 + parameterStringWithEmptyDefault: data.parameterStringWithEmptyDefault, 351 351 + parameterStringWithNoDefault: data.parameterStringWithNoDefault, 352 352 + parameterStringNullableWithNoDefault: data.parameterStringNullableWithNoDefault, 353 353 + parameterStringNullableWithDefault: data.parameterStringNullableWithDefault 354 354 + } 355 355 + }); }; 356 356 + 357 357 + /** 358 358 + * @throws ApiError 359 359 + */ 360 360 + export const duplicateName = function (): Observable<void> { return __request(OpenAPI, this.http, { 361 361 + method: 'GET', 362 362 + url: '/api/v{api-version}/duplicate' 363 363 + }); }; 364 364 + 365 365 + /** 366 366 + * @throws ApiError 367 367 + */ 368 368 + export const duplicateName1 = function (): Observable<void> { return __request(OpenAPI, this.http, { 369 369 + method: 'POST', 370 370 + url: '/api/v{api-version}/duplicate' 371 371 + }); }; 372 372 + 373 373 + /** 374 374 + * @throws ApiError 375 375 + */ 376 376 + export const duplicateName2 = function (): Observable<void> { return __request(OpenAPI, this.http, { 377 377 + method: 'PUT', 378 378 + url: '/api/v{api-version}/duplicate' 379 379 + }); }; 380 380 + 381 381 + /** 382 382 + * @throws ApiError 383 383 + */ 384 384 + export const duplicateName3 = function (): Observable<void> { return __request(OpenAPI, this.http, { 385 385 + method: 'DELETE', 386 386 + url: '/api/v{api-version}/duplicate' 387 387 + }); }; 388 388 + 389 389 + /** 390 390 + * @returns void Success 391 391 + * @throws ApiError 392 392 + */ 393 393 + export const callWithNoContentResponse = function (): Observable<CallWithNoContentResponseResponse> { return __request(OpenAPI, this.http, { 394 394 + method: 'GET', 395 395 + url: '/api/v{api-version}/no-content' 396 396 + }); }; 397 397 + 398 398 + /** 399 399 + * @returns number Response is a simple number 400 400 + * @returns void Success 401 401 + * @throws ApiError 402 402 + */ 403 403 + export const callWithResponseAndNoContentResponse = function (): Observable<CallWithResponseAndNoContentResponseResponse> { return __request(OpenAPI, this.http, { 404 404 + method: 'GET', 405 405 + url: '/api/v{api-version}/multiple-tags/response-and-no-content' 406 406 + }); }; 407 407 + 408 408 + /** 409 409 + * @returns _400 410 410 + * @throws ApiError 411 411 + */ 412 412 + export const dummyA = function (): Observable<DummyAResponse> { return __request(OpenAPI, this.http, { 413 413 + method: 'GET', 414 414 + url: '/api/v{api-version}/multiple-tags/a' 415 415 + }); }; 416 416 + 417 417 + /** 418 418 + * @returns void Success 419 419 + * @throws ApiError 420 420 + */ 421 421 + export const dummyB = function (): Observable<DummyBResponse> { return __request(OpenAPI, this.http, { 422 422 + method: 'GET', 423 423 + url: '/api/v{api-version}/multiple-tags/b' 424 424 + }); }; 425 425 + 426 426 + /** 427 427 + * @returns import 428 428 + * @throws ApiError 429 429 + */ 430 430 + export const callWithResponse = function (): Observable<CallWithResponseResponse> { return __request(OpenAPI, this.http, { 431 431 + method: 'GET', 432 432 + url: '/api/v{api-version}/response' 433 433 + }); }; 434 434 + 435 435 + /** 436 436 + * @returns unknown Message for 200 response 437 437 + * @returns ModelWithString Message for 201 response 438 438 + * @returns ModelWithString Message for 202 response 439 439 + * @throws ApiError 440 440 + */ 441 441 + export const callWithDuplicateResponses = function (): Observable<CallWithDuplicateResponsesResponse> { return __request(OpenAPI, this.http, { 442 442 + method: 'POST', 443 443 + url: '/api/v{api-version}/response', 444 444 + errors: { 445 445 + 500: 'Message for 500 error', 446 446 + 501: 'Message for 501 error', 447 447 + 502: 'Message for 502 error', 448 448 + '4XX': 'Message for 4XX errors', 449 449 + default: 'Default error response' 450 450 + } 451 451 + }); }; 452 452 + 453 453 + /** 454 454 + * @returns unknown Message for 200 response 455 455 + * @returns ModelThatExtends Message for 201 response 456 456 + * @returns ModelThatExtendsExtends Message for 202 response 457 457 + * @throws ApiError 458 458 + */ 459 459 + export const callWithResponses = function (): Observable<CallWithResponsesResponse> { return __request(OpenAPI, this.http, { 460 460 + method: 'PUT', 461 461 + url: '/api/v{api-version}/response', 462 462 + errors: { 463 463 + 500: 'Message for 500 error', 464 464 + 501: 'Message for 501 error', 465 465 + 502: 'Message for 502 error', 466 466 + default: 'Message for default response' 467 467 + } 468 468 + }); }; 469 469 + 470 470 + /** 471 471 + * @param data The data for the request. 472 472 + * @param data.parameterArrayCsv This is an array parameter that is sent as csv format (comma-separated values) 473 473 + * @param data.parameterArraySsv This is an array parameter that is sent as ssv format (space-separated values) 474 474 + * @param data.parameterArrayTsv This is an array parameter that is sent as tsv format (tab-separated values) 475 475 + * @param data.parameterArrayPipes This is an array parameter that is sent as pipes format (pipe-separated values) 476 476 + * @param data.parameterArrayMulti This is an array parameter that is sent as multi format (multiple parameter instances) 477 477 + * @throws ApiError 478 478 + */ 479 479 + export const collectionFormat = function (data: CollectionFormatData): Observable<void> { return __request(OpenAPI, this.http, { 480 480 + method: 'GET', 481 481 + url: '/api/v{api-version}/collectionFormat', 482 482 + query: { 483 483 + parameterArrayCSV: data.parameterArrayCsv, 484 484 + parameterArraySSV: data.parameterArraySsv, 485 485 + parameterArrayTSV: data.parameterArrayTsv, 486 486 + parameterArrayPipes: data.parameterArrayPipes, 487 487 + parameterArrayMulti: data.parameterArrayMulti 488 488 + } 489 489 + }); }; 490 490 + 491 491 + /** 492 492 + * @param data The data for the request. 493 493 + * @param data.parameterArray This is an array parameter 494 494 + * @param data.parameterDictionary This is a dictionary parameter 495 495 + * @param data.parameterEnum This is an enum parameter 496 496 + * @param data.parameterNumber This is a number parameter 497 497 + * @param data.parameterString This is a string parameter 498 498 + * @param data.parameterBoolean This is a boolean parameter 499 499 + * @param data.parameterObject This is an object parameter 500 500 + * @param data.id This is a number parameter 501 501 + * @returns number Response is a simple number 502 502 + * @returns string Response is a simple string 503 503 + * @returns boolean Response is a simple boolean 504 504 + * @returns unknown Response is a simple object 505 505 + * @throws ApiError 506 506 + */ 507 507 + export const types = function (data: TypesData): Observable<TypesResponse> { return __request(OpenAPI, this.http, { 508 508 + method: 'GET', 509 509 + url: '/api/v{api-version}/types', 510 510 + path: { 511 511 + id: data.id 512 512 + }, 513 513 + query: { 514 514 + parameterNumber: data.parameterNumber, 515 515 + parameterString: data.parameterString, 516 516 + parameterBoolean: data.parameterBoolean, 517 517 + parameterObject: data.parameterObject, 518 518 + parameterArray: data.parameterArray, 519 519 + parameterDictionary: data.parameterDictionary, 520 520 + parameterEnum: data.parameterEnum 521 521 + } 522 522 + }); }; 523 523 + 524 524 + /** 525 525 + * @param data The data for the request. 526 526 + * @param data.formData 527 527 + * @returns boolean 528 528 + * @throws ApiError 529 529 + */ 530 530 + export const uploadFile = function (data: UploadFileData): Observable<UploadFileResponse> { return __request(OpenAPI, this.http, { 531 531 + method: 'POST', 532 532 + url: '/api/v{api-version}/upload', 533 533 + formData: data.formData, 534 534 + mediaType: 'application/x-www-form-urlencoded' 535 535 + }); }; 536 536 + 537 537 + /** 538 538 + * @param data The data for the request. 539 539 + * @param data.id 540 540 + * @returns binary Success 541 541 + * @throws ApiError 542 542 + */ 543 543 + export const fileResponse = function (data: FileResponseData): Observable<FileResponseResponse> { return __request(OpenAPI, this.http, { 544 544 + method: 'GET', 545 545 + url: '/api/v{api-version}/file/{id}', 546 546 + path: { 547 547 + id: data.id 548 548 + } 549 549 + }); }; 550 550 + 551 551 + /** 552 552 + * @param data The data for the request. 553 553 + * @param data.parameterObject Parameter containing object 554 554 + * @param data.parameterReference Parameter containing reference 555 555 + * @returns ModelWithString Successful response 556 556 + * @throws ApiError 557 557 + */ 558 558 + export const complexTypes = function (data: ComplexTypesData): Observable<ComplexTypesResponse> { return __request(OpenAPI, this.http, { 559 559 + method: 'GET', 560 560 + url: '/api/v{api-version}/complex', 561 561 + query: { 562 562 + parameterObject: data.parameterObject, 563 563 + parameterReference: data.parameterReference 564 564 + }, 565 565 + errors: { 566 566 + 400: '400 `server` error', 567 567 + 500: '500 server error' 568 568 + } 569 569 + }); }; 570 570 + 571 571 + /** 572 572 + * @param data The data for the request. 573 573 + * @param data.formData 574 574 + * @throws ApiError 575 575 + */ 576 576 + export const multipartRequest = function (data: MultipartRequestData = {}): Observable<void> { return __request(OpenAPI, this.http, { 577 577 + method: 'POST', 578 578 + url: '/api/v{api-version}/multipart', 579 579 + formData: data.formData, 580 580 + mediaType: 'multipart/form-data' 581 581 + }); }; 582 582 + 583 583 + /** 584 584 + * @returns unknown OK 585 585 + * @throws ApiError 586 586 + */ 587 587 + export const multipartResponse = function (): Observable<MultipartResponseResponse> { return __request(OpenAPI, this.http, { 588 588 + method: 'GET', 589 589 + url: '/api/v{api-version}/multipart' 590 590 + }); }; 591 591 + 592 592 + /** 593 593 + * @param data The data for the request. 594 594 + * @param data.id 595 595 + * @param data.requestBody 596 596 + * @returns ModelWithString Success 597 597 + * @throws ApiError 598 598 + */ 599 599 + export const complexParams = function (data: ComplexParamsData): Observable<ComplexParamsResponse> { return __request(OpenAPI, this.http, { 600 600 + method: 'PUT', 601 601 + url: '/api/v{api-version}/complex/{id}', 602 602 + path: { 603 603 + id: data.id 604 604 + }, 605 605 + body: data.requestBody, 606 606 + mediaType: 'application/json-patch+json' 607 607 + }); }; 608 608 + 609 609 + /** 610 610 + * @returns string Successful response 611 611 + * @throws ApiError 612 612 + */ 613 613 + export const callWithResultFromHeader = function (): Observable<CallWithResultFromHeaderResponse> { return __request(OpenAPI, this.http, { 614 614 + method: 'POST', 615 615 + url: '/api/v{api-version}/header', 616 616 + responseHeader: 'operation-location', 617 617 + errors: { 618 618 + 400: '400 server error', 619 619 + 500: '500 server error' 620 620 + } 621 621 + }); }; 622 622 + 623 623 + /** 624 624 + * @param data The data for the request. 625 625 + * @param data.status Status code to return 626 626 + * @returns unknown Custom message: Successful response 627 627 + * @throws ApiError 628 628 + */ 629 629 + export const testErrorCode = function (data: TestErrorCodeData): Observable<TestErrorCodeResponse> { return __request(OpenAPI, this.http, { 630 630 + method: 'POST', 631 631 + url: '/api/v{api-version}/error', 632 632 + query: { 633 633 + status: data.status 634 634 + }, 635 635 + errors: { 636 636 + 500: 'Custom message: Internal Server Error', 637 637 + 501: 'Custom message: Not Implemented', 638 638 + 502: 'Custom message: Bad Gateway', 639 639 + 503: 'Custom message: Service Unavailable' 640 640 + } 641 641 + }); }; 642 642 + 643 643 + /** 644 644 + * @param data The data for the request. 645 645 + * @param data.nonAsciiParamæøåÆøÅöôêÊ Dummy input param 646 646 + * @returns NonAsciiStringæøåÆØÅöôêÊ字符串 Successful response 647 647 + * @throws ApiError 648 648 + */ 649 649 + export const nonAsciiæøåÆøÅöôêÊ字符串 = function (data: NonAsciiæøåÆøÅöôêÊ字符串Data): Observable<NonAsciiæøåÆøÅöôêÊ字符串Response> { return __request(OpenAPI, this.http, { 650 650 + method: 'POST', 651 651 + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串', 652 652 + query: { 653 653 + 'nonAsciiParamæøåÆØÅöôêÊ': data.nonAsciiParamæøåÆøÅöôêÊ 654 654 + } 655 655 + }); }; 656 656 + 657 657 + /** 658 658 + * Login User 659 659 + * @param data The data for the request. 660 660 + * @param data.formData 661 661 + * @throws ApiError 662 662 + */ 663 663 + export const putWithFormUrlEncoded = function (data: PutWithFormUrlEncodedData): Observable<void> { return __request(OpenAPI, this.http, { 664 664 + method: 'PUT', 665 665 + url: '/api/v{api-version}/non-ascii-æøåÆØÅöôêÊ字符串', 666 666 + formData: data.formData, 667 667 + mediaType: 'application/x-www-form-urlencoded' 668 668 + }); };

+1389

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable/types.gen.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + 3 3 + /** 4 4 + * Model with number-only name 5 5 + */ 6 6 + export type _400 = string; 7 7 + 8 8 + /** 9 9 + * Testing multiline comments in string: First line 10 10 + * Second line 11 11 + * 12 12 + * Fourth line 13 13 + */ 14 14 + export type camelCaseCommentWithBreaks = number; 15 15 + 16 16 + /** 17 17 + * Testing multiline comments in string: First line 18 18 + * Second line 19 19 + * 20 20 + * Fourth line 21 21 + */ 22 22 + export type CommentWithBreaks = number; 23 23 + 24 24 + /** 25 25 + * Testing backticks in string: `backticks` and ```multiple backticks``` should work 26 26 + */ 27 27 + export type CommentWithBackticks = number; 28 28 + 29 29 + /** 30 30 + * Testing backticks and quotes in string: `backticks`, 'quotes', "double quotes" and ```multiple backticks``` should work 31 31 + */ 32 32 + export type CommentWithBackticksAndQuotes = number; 33 33 + 34 34 + /** 35 35 + * Testing slashes in string: \backwards\\\ and /forwards/// should work 36 36 + */ 37 37 + export type CommentWithSlashes = number; 38 38 + 39 39 + /** 40 40 + * Testing expression placeholders in string: ${expression} should work 41 41 + */ 42 42 + export type CommentWithExpressionPlaceholders = number; 43 43 + 44 44 + /** 45 45 + * Testing quotes in string: 'single quote''' and "double quotes""" should work 46 46 + */ 47 47 + export type CommentWithQuotes = number; 48 48 + 49 49 + /** 50 50 + * Testing reserved characters in string: * inline * and ** inline ** should work 51 51 + */ 52 52 + export type CommentWithReservedCharacters = number; 53 53 + 54 54 + /** 55 55 + * This is a simple number 56 56 + */ 57 57 + export type SimpleInteger = number; 58 58 + 59 59 + /** 60 60 + * This is a simple boolean 61 61 + */ 62 62 + export type SimpleBoolean = boolean; 63 63 + 64 64 + /** 65 65 + * This is a simple string 66 66 + */ 67 67 + export type SimpleString = string; 68 68 + 69 69 + /** 70 70 + * A string with non-ascii (unicode) characters valid in typescript identifiers (æøåÆØÅöÔèÈ字符串) 71 71 + */ 72 72 + export type NonAsciiStringæøåÆØÅöôêÊ字符串 = string; 73 73 + 74 74 + /** 75 75 + * This is a simple file 76 76 + */ 77 77 + export type SimpleFile = (Blob | File); 78 78 + 79 79 + /** 80 80 + * This is a simple reference 81 81 + */ 82 82 + export type SimpleReference = ModelWithString; 83 83 + 84 84 + /** 85 85 + * This is a simple string 86 86 + */ 87 87 + export type SimpleStringWithPattern = (string) | null; 88 88 + 89 89 + /** 90 90 + * This is a simple enum with strings 91 91 + */ 92 92 + export type EnumWithStrings = 'Success' | 'Warning' | 'Error' | "'Single Quote'" | '"Double Quotes"' | 'Non-ascii: øæåôöØÆÅÔÖ字符串'; 93 93 + 94 94 + export type EnumWithReplacedCharacters = "'Single Quote'" | '"Double Quotes"' | 'øæåôöØÆÅÔÖ字符串' | 3.1 | ''; 95 95 + 96 96 + /** 97 97 + * This is a simple enum with numbers 98 98 + */ 99 99 + export type EnumWithNumbers = 1 | 2 | 3 | 1.1 | 1.2 | 1.3 | 100 | 200 | 300 | -100 | -200 | -300 | -1.1 | -1.2 | -1.3; 100 100 + 101 101 + /** 102 102 + * Success=1,Warning=2,Error=3 103 103 + */ 104 104 + export type EnumFromDescription = number; 105 105 + 106 106 + /** 107 107 + * This is a simple enum with numbers 108 108 + */ 109 109 + export type EnumWithExtensions = 200 | 400 | 500; 110 110 + 111 111 + export type EnumWithXEnumNames = 0 | 1 | 2; 112 112 + 113 113 + /** 114 114 + * This is a simple array with numbers 115 115 + */ 116 116 + export type ArrayWithNumbers = Array<(number)>; 117 117 + 118 118 + /** 119 119 + * This is a simple array with booleans 120 120 + */ 121 121 + export type ArrayWithBooleans = Array<(boolean)>; 122 122 + 123 123 + /** 124 124 + * This is a simple array with strings 125 125 + */ 126 126 + export type ArrayWithStrings = Array<(string)>; 127 127 + 128 128 + /** 129 129 + * This is a simple array with references 130 130 + */ 131 131 + export type ArrayWithReferences = Array<ModelWithString>; 132 132 + 133 133 + /** 134 134 + * This is a simple array containing an array 135 135 + */ 136 136 + export type ArrayWithArray = Array<Array<ModelWithString>>; 137 137 + 138 138 + /** 139 139 + * This is a simple array with properties 140 140 + */ 141 141 + export type ArrayWithProperties = Array<{ 142 142 + '16x16'?: camelCaseCommentWithBreaks; 143 143 + bar?: string; 144 144 + }>; 145 145 + 146 146 + /** 147 147 + * This is a simple array with any of properties 148 148 + */ 149 149 + export type ArrayWithAnyOfProperties = Array<({ 150 150 + foo?: string; 151 151 + } | { 152 152 + bar?: string; 153 153 + })>; 154 154 + 155 155 + export type AnyOfAnyAndNull = { 156 156 + data?: (unknown | null); 157 157 + }; 158 158 + 159 159 + /** 160 160 + * This is a simple array with any of properties 161 161 + */ 162 162 + export type AnyOfArrays = { 163 163 + results?: Array<({ 164 164 + foo?: string; 165 165 + } | { 166 166 + bar?: string; 167 167 + })>; 168 168 + }; 169 169 + 170 170 + /** 171 171 + * This is a string dictionary 172 172 + */ 173 173 + export type DictionaryWithString = { 174 174 + [key: string]: (string); 175 175 + }; 176 176 + 177 177 + export type DictionaryWithPropertiesAndAdditionalProperties = { 178 178 + foo?: number; 179 179 + bar?: boolean; 180 180 + [key: string]: (string | number | boolean) | undefined; 181 181 + }; 182 182 + 183 183 + /** 184 184 + * This is a string reference 185 185 + */ 186 186 + export type DictionaryWithReference = { 187 187 + [key: string]: ModelWithString; 188 188 + }; 189 189 + 190 190 + /** 191 191 + * This is a complex dictionary 192 192 + */ 193 193 + export type DictionaryWithArray = { 194 194 + [key: string]: Array<ModelWithString>; 195 195 + }; 196 196 + 197 197 + /** 198 198 + * This is a string dictionary 199 199 + */ 200 200 + export type DictionaryWithDictionary = { 201 201 + [key: string]: { 202 202 + [key: string]: (string); 203 203 + }; 204 204 + }; 205 205 + 206 206 + /** 207 207 + * This is a complex dictionary 208 208 + */ 209 209 + export type DictionaryWithProperties = { 210 210 + [key: string]: { 211 211 + foo?: string; 212 212 + bar?: string; 213 213 + }; 214 214 + }; 215 215 + 216 216 + /** 217 217 + * This is a model with one number property 218 218 + */ 219 219 + export type ModelWithInteger = { 220 220 + /** 221 221 + * This is a simple number property 222 222 + */ 223 223 + prop?: number; 224 224 + }; 225 225 + 226 226 + /** 227 227 + * This is a model with one boolean property 228 228 + */ 229 229 + export type ModelWithBoolean = { 230 230 + /** 231 231 + * This is a simple boolean property 232 232 + */ 233 233 + prop?: boolean; 234 234 + }; 235 235 + 236 236 + /** 237 237 + * This is a model with one string property 238 238 + */ 239 239 + export type ModelWithString = { 240 240 + /** 241 241 + * This is a simple string property 242 242 + */ 243 243 + prop?: string; 244 244 + }; 245 245 + 246 246 + /** 247 247 + * This is a model with one string property 248 248 + */ 249 249 + export type ModelWithStringError = { 250 250 + /** 251 251 + * This is a simple string property 252 252 + */ 253 253 + prop?: string; 254 254 + }; 255 255 + 256 256 + /** 257 257 + * `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) 258 258 + */ 259 259 + export type Model_From_Zendesk = string; 260 260 + 261 261 + /** 262 262 + * This is a model with one string property 263 263 + */ 264 264 + export type ModelWithNullableString = { 265 265 + /** 266 266 + * This is a simple string property 267 267 + */ 268 268 + nullableProp1?: (string) | null; 269 269 + /** 270 270 + * This is a simple string property 271 271 + */ 272 272 + nullableRequiredProp1: (string) | null; 273 273 + /** 274 274 + * This is a simple string property 275 275 + */ 276 276 + nullableProp2?: (string) | null; 277 277 + /** 278 278 + * This is a simple string property 279 279 + */ 280 280 + nullableRequiredProp2: (string) | null; 281 281 + /** 282 282 + * This is a simple enum with strings 283 283 + */ 284 284 + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; 285 285 + }; 286 286 + 287 287 + /** 288 288 + * This is a simple enum with strings 289 289 + */ 290 290 + export type foo_bar_enum = 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; 291 291 + 292 292 + /** 293 293 + * This is a model with one enum 294 294 + */ 295 295 + export type ModelWithEnum = { 296 296 + /** 297 297 + * This is a simple enum with strings 298 298 + */ 299 299 + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; 300 300 + /** 301 301 + * These are the HTTP error code enums 302 302 + */ 303 303 + statusCode?: '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; 304 304 + /** 305 305 + * Simple boolean enum 306 306 + */ 307 307 + bool?: boolean; 308 308 + }; 309 309 + 310 310 + /** 311 311 + * These are the HTTP error code enums 312 312 + */ 313 313 + export type statusCode = '100' | '200 FOO' | '300 FOO_BAR' | '400 foo-bar' | '500 foo.bar' | '600 foo&bar'; 314 314 + 315 315 + /** 316 316 + * This is a model with one enum with escaped name 317 317 + */ 318 318 + export type ModelWithEnumWithHyphen = { 319 319 + 'foo-bar-baz-qux'?: '3.0'; 320 320 + }; 321 321 + 322 322 + export type foo_bar_baz_qux = '3.0'; 323 323 + 324 324 + /** 325 325 + * This is a model with one enum 326 326 + */ 327 327 + export type ModelWithEnumFromDescription = { 328 328 + /** 329 329 + * Success=1,Warning=2,Error=3 330 330 + */ 331 331 + test?: number; 332 332 + }; 333 333 + 334 334 + /** 335 335 + * This is a model with nested enums 336 336 + */ 337 337 + export type ModelWithNestedEnums = { 338 338 + dictionaryWithEnum?: { 339 339 + [key: string]: ('Success' | 'Warning' | 'Error'); 340 340 + }; 341 341 + dictionaryWithEnumFromDescription?: { 342 342 + [key: string]: (number); 343 343 + }; 344 344 + arrayWithEnum?: Array<('Success' | 'Warning' | 'Error')>; 345 345 + arrayWithDescription?: Array<(number)>; 346 346 + /** 347 347 + * This is a simple enum with strings 348 348 + */ 349 349 + 'foo_bar-enum'?: 'Success' | 'Warning' | 'Error' | 'ØÆÅ字符串'; 350 350 + }; 351 351 + 352 352 + /** 353 353 + * This is a model with one property containing a reference 354 354 + */ 355 355 + export type ModelWithReference = { 356 356 + prop?: ModelWithProperties; 357 357 + }; 358 358 + 359 359 + /** 360 360 + * This is a model with one property containing an array 361 361 + */ 362 362 + export type ModelWithArrayReadOnlyAndWriteOnly = { 363 363 + prop?: Array<ModelWithReadOnlyAndWriteOnly>; 364 364 + propWithFile?: Array<((Blob | File))>; 365 365 + propWithNumber?: Array<(number)>; 366 366 + }; 367 367 + 368 368 + /** 369 369 + * This is a model with one property containing an array 370 370 + */ 371 371 + export type ModelWithArray = { 372 372 + prop?: Array<ModelWithString>; 373 373 + propWithFile?: Array<((Blob | File))>; 374 374 + propWithNumber?: Array<(number)>; 375 375 + }; 376 376 + 377 377 + /** 378 378 + * This is a model with one property containing a dictionary 379 379 + */ 380 380 + export type ModelWithDictionary = { 381 381 + prop?: { 382 382 + [key: string]: (string); 383 383 + }; 384 384 + }; 385 385 + 386 386 + /** 387 387 + * This is a deprecated model with a deprecated property 388 388 + * @deprecated 389 389 + */ 390 390 + export type DeprecatedModel = { 391 391 + /** 392 392 + * This is a deprecated property 393 393 + * @deprecated 394 394 + */ 395 395 + prop?: string; 396 396 + }; 397 397 + 398 398 + /** 399 399 + * This is a model with one property containing a circular reference 400 400 + */ 401 401 + export type ModelWithCircularReference = { 402 402 + prop?: ModelWithCircularReference; 403 403 + }; 404 404 + 405 405 + /** 406 406 + * This is a model with one property with a 'one of' relationship 407 407 + */ 408 408 + export type CompositionWithOneOf = { 409 409 + propA?: (ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary); 410 410 + }; 411 411 + 412 412 + /** 413 413 + * This is a model with one property with a 'one of' relationship where the options are not $ref 414 414 + */ 415 415 + export type CompositionWithOneOfAnonymous = { 416 416 + propA?: ({ 417 417 + propA?: string; 418 418 + } | string | number); 419 419 + }; 420 420 + 421 421 + /** 422 422 + * Circle 423 423 + */ 424 424 + export type ModelCircle = { 425 425 + kind: 'circle'; 426 426 + radius?: number; 427 427 + }; 428 428 + 429 429 + /** 430 430 + * Square 431 431 + */ 432 432 + export type ModelSquare = { 433 433 + kind: 'square'; 434 434 + sideLength?: number; 435 435 + }; 436 436 + 437 437 + /** 438 438 + * This is a model with one property with a 'one of' relationship where the options are not $ref 439 439 + */ 440 440 + export type CompositionWithOneOfDiscriminator = ModelCircle | ModelSquare; 441 441 + 442 442 + /** 443 443 + * This is a model with one property with a 'any of' relationship 444 444 + */ 445 445 + export type CompositionWithAnyOf = { 446 446 + propA?: (ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary); 447 447 + }; 448 448 + 449 449 + /** 450 450 + * This is a model with one property with a 'any of' relationship where the options are not $ref 451 451 + */ 452 452 + export type CompositionWithAnyOfAnonymous = { 453 453 + propA?: ({ 454 454 + propA?: string; 455 455 + } | string | number); 456 456 + }; 457 457 + 458 458 + /** 459 459 + * This is a model with nested 'any of' property with a type null 460 460 + */ 461 461 + export type CompositionWithNestedAnyAndTypeNull = { 462 462 + propA?: (Array<(ModelWithDictionary | null)> | Array<(ModelWithArray | null)>); 463 463 + }; 464 464 + 465 465 + export type _3e_num_1Период = 'Bird' | 'Dog'; 466 466 + 467 467 + export type ConstValue = "ConstValue"; 468 468 + 469 469 + /** 470 470 + * This is a model with one property with a 'any of' relationship where the options are not $ref 471 471 + */ 472 472 + export type CompositionWithNestedAnyOfAndNull = { 473 473 + propA?: (Array<(_3e_num_1Период | ConstValue)> | null); 474 474 + }; 475 475 + 476 476 + /** 477 477 + * This is a model with one property with a 'one of' relationship 478 478 + */ 479 479 + export type CompositionWithOneOfAndNullable = { 480 480 + propA?: (({ 481 481 + boolean?: boolean; 482 482 + } | ModelWithEnum | ModelWithArray | ModelWithDictionary) | null); 483 483 + }; 484 484 + 485 485 + /** 486 486 + * This is a model that contains a simple dictionary within composition 487 487 + */ 488 488 + export type CompositionWithOneOfAndSimpleDictionary = { 489 489 + propA?: (boolean | { 490 490 + [key: string]: (number); 491 491 + }); 492 492 + }; 493 493 + 494 494 + /** 495 495 + * This is a model that contains a dictionary of simple arrays within composition 496 496 + */ 497 497 + export type CompositionWithOneOfAndSimpleArrayDictionary = { 498 498 + propA?: (boolean | { 499 499 + [key: string]: Array<(boolean)>; 500 500 + }); 501 501 + }; 502 502 + 503 503 + /** 504 504 + * This is a model that contains a dictionary of complex arrays (composited) within composition 505 505 + */ 506 506 + export type CompositionWithOneOfAndComplexArrayDictionary = { 507 507 + propA?: (boolean | { 508 508 + [key: string]: Array<(number | string)>; 509 509 + }); 510 510 + }; 511 511 + 512 512 + /** 513 513 + * This is a model with one property with a 'all of' relationship 514 514 + */ 515 515 + export type CompositionWithAllOfAndNullable = { 516 516 + propA?: (({ 517 517 + boolean?: boolean; 518 518 + } & ModelWithEnum & ModelWithArray & ModelWithDictionary) | null); 519 519 + }; 520 520 + 521 521 + /** 522 522 + * This is a model with one property with a 'any of' relationship 523 523 + */ 524 524 + export type CompositionWithAnyOfAndNullable = { 525 525 + propA?: (({ 526 526 + boolean?: boolean; 527 527 + } | ModelWithEnum | ModelWithArray | ModelWithDictionary) | null); 528 528 + }; 529 529 + 530 530 + /** 531 531 + * This is a base model with two simple optional properties 532 532 + */ 533 533 + export type CompositionBaseModel = { 534 534 + firstName?: string; 535 535 + lastname?: string; 536 536 + }; 537 537 + 538 538 + /** 539 539 + * This is a model that extends the base model 540 540 + */ 541 541 + export type CompositionExtendedModel = CompositionBaseModel & { 542 542 + firstName: string; 543 543 + lastname: string; 544 544 + age: number; 545 545 + }; 546 546 + 547 547 + /** 548 548 + * This is a model with one nested property 549 549 + */ 550 550 + export type ModelWithProperties = { 551 551 + required: string; 552 552 + readonly requiredAndReadOnly: string; 553 553 + requiredAndNullable: (string) | null; 554 554 + string?: string; 555 555 + number?: number; 556 556 + boolean?: boolean; 557 557 + reference?: ModelWithString; 558 558 + 'property with space'?: string; 559 559 + default?: string; 560 560 + try?: string; 561 561 + readonly '@namespace.string'?: string; 562 562 + readonly '@namespace.integer'?: number; 563 563 + }; 564 564 + 565 565 + /** 566 566 + * This is a model with one nested property 567 567 + */ 568 568 + export type ModelWithNestedProperties = { 569 569 + readonly first: { 570 570 + readonly second: { 571 571 + readonly third: (string) | null; 572 572 + } | null; 573 573 + } | null; 574 574 + }; 575 575 + 576 576 + /** 577 577 + * This is a model with duplicated properties 578 578 + */ 579 579 + export type ModelWithDuplicateProperties = { 580 580 + prop?: ModelWithString; 581 581 + }; 582 582 + 583 583 + /** 584 584 + * This is a model with ordered properties 585 585 + */ 586 586 + export type ModelWithOrderedProperties = { 587 587 + zebra?: string; 588 588 + apple?: string; 589 589 + hawaii?: string; 590 590 + }; 591 591 + 592 592 + /** 593 593 + * This is a model with duplicated imports 594 594 + */ 595 595 + export type ModelWithDuplicateImports = { 596 596 + propA?: ModelWithString; 597 597 + propB?: ModelWithString; 598 598 + propC?: ModelWithString; 599 599 + }; 600 600 + 601 601 + /** 602 602 + * This is a model that extends another model 603 603 + */ 604 604 + export type ModelThatExtends = ModelWithString & { 605 605 + propExtendsA?: string; 606 606 + propExtendsB?: ModelWithString; 607 607 + }; 608 608 + 609 609 + /** 610 610 + * This is a model that extends another model 611 611 + */ 612 612 + export type ModelThatExtendsExtends = ModelWithString & ModelThatExtends & { 613 613 + propExtendsC?: string; 614 614 + propExtendsD?: ModelWithString; 615 615 + }; 616 616 + 617 617 + /** 618 618 + * This is a model that contains a some patterns 619 619 + */ 620 620 + export type ModelWithPattern = { 621 621 + key: string; 622 622 + name: string; 623 623 + readonly enabled?: boolean; 624 624 + readonly modified?: string; 625 625 + id?: string; 626 626 + text?: string; 627 627 + patternWithSingleQuotes?: string; 628 628 + patternWithNewline?: string; 629 629 + patternWithBacktick?: string; 630 630 + }; 631 631 + 632 632 + export type File = { 633 633 + readonly id?: string; 634 634 + readonly updated_at?: string; 635 635 + readonly created_at?: string; 636 636 + mime: string; 637 637 + readonly file?: string; 638 638 + }; 639 639 + 640 640 + export type _default = { 641 641 + name?: string; 642 642 + }; 643 643 + 644 644 + export type Pageable = { 645 645 + page?: number; 646 646 + size?: number; 647 647 + sort?: Array<(string)>; 648 648 + }; 649 649 + 650 650 + /** 651 651 + * This is a free-form object without additionalProperties. 652 652 + */ 653 653 + export type FreeFormObjectWithoutAdditionalProperties = { 654 654 + [key: string]: unknown; 655 655 + }; 656 656 + 657 657 + /** 658 658 + * This is a free-form object with additionalProperties: true. 659 659 + */ 660 660 + export type FreeFormObjectWithAdditionalPropertiesEqTrue = { 661 661 + [key: string]: unknown; 662 662 + }; 663 663 + 664 664 + /** 665 665 + * This is a free-form object with additionalProperties: {}. 666 666 + */ 667 667 + export type FreeFormObjectWithAdditionalPropertiesEqEmptyObject = { 668 668 + [key: string]: unknown; 669 669 + }; 670 670 + 671 671 + export type ModelWithConst = { 672 672 + String?: "String"; 673 673 + number?: 0; 674 674 + null?: null; 675 675 + withType?: "Some string"; 676 676 + }; 677 677 + 678 678 + /** 679 679 + * This is a model with one property and additionalProperties: true 680 680 + */ 681 681 + export type ModelWithAdditionalPropertiesEqTrue = { 682 682 + /** 683 683 + * This is a simple string property 684 684 + */ 685 685 + prop?: string; 686 686 + [key: string]: unknown | string; 687 687 + }; 688 688 + 689 689 + export type NestedAnyOfArraysNullable = { 690 690 + nullableArray?: (Array<(string | boolean)> | null); 691 691 + }; 692 692 + 693 693 + export type CompositionWithOneOfAndProperties = ({ 694 694 + foo: ParameterSimpleParameter; 695 695 + } | { 696 696 + bar: NonAsciiStringæøåÆØÅöôêÊ字符串; 697 697 + }) & { 698 698 + baz: (number) | null; 699 699 + qux: number; 700 700 + }; 701 701 + 702 702 + /** 703 703 + * An object that can be null 704 704 + */ 705 705 + export type NullableObject = { 706 706 + foo?: string; 707 707 + } | null; 708 708 + 709 709 + /** 710 710 + * Some % character 711 711 + */ 712 712 + export type CharactersInDescription = string; 713 713 + 714 714 + export type ModelWithNullableObject = { 715 715 + data?: NullableObject; 716 716 + }; 717 717 + 718 718 + export type ModelWithOneOfEnum = { 719 719 + foo: 'Bar'; 720 720 + } | { 721 721 + foo: 'Baz'; 722 722 + } | { 723 723 + foo: 'Qux'; 724 724 + } | { 725 725 + content: string; 726 726 + foo: 'Quux'; 727 727 + } | { 728 728 + content: [ 729 729 + (string), 730 730 + (string) 731 731 + ]; 732 732 + foo: 'Corge'; 733 733 + }; 734 734 + 735 735 + export type foo = 'Bar'; 736 736 + 737 737 + export type ModelWithNestedArrayEnumsDataFoo = 'foo' | 'bar'; 738 738 + 739 739 + export type ModelWithNestedArrayEnumsDataBar = 'baz' | 'qux'; 740 740 + 741 741 + export type ModelWithNestedArrayEnumsData = { 742 742 + foo?: Array<ModelWithNestedArrayEnumsDataFoo>; 743 743 + bar?: Array<ModelWithNestedArrayEnumsDataBar>; 744 744 + }; 745 745 + 746 746 + export type ModelWithNestedArrayEnums = { 747 747 + array_strings?: Array<(string)>; 748 748 + data?: (ModelWithNestedArrayEnumsData); 749 749 + }; 750 750 + 751 751 + export type ModelWithNestedCompositionEnums = { 752 752 + foo?: (ModelWithNestedArrayEnumsDataFoo); 753 753 + }; 754 754 + 755 755 + export type ModelWithReadOnlyAndWriteOnly = { 756 756 + foo: string; 757 757 + readonly bar: string; 758 758 + baz: string; 759 759 + }; 760 760 + 761 761 + export type ModelWithConstantSizeArray = [ 762 762 + number, 763 763 + number 764 764 + ]; 765 765 + 766 766 + export type ModelWithAnyOfConstantSizeArray = [ 767 767 + (number | string), 768 768 + (number | string), 769 769 + (number | string) 770 770 + ]; 771 771 + 772 772 + export type ModelWithPrefixItemsConstantSizeArray = [ 773 773 + ModelWithInteger, 774 774 + (number | string), 775 775 + string 776 776 + ]; 777 777 + 778 778 + export type ModelWithAnyOfConstantSizeArrayNullable = [ 779 779 + ((number) | null | string), 780 780 + ((number) | null | string), 781 781 + ((number) | null | string) 782 782 + ]; 783 783 + 784 784 + export type ModelWithAnyOfConstantSizeArrayWithNSizeAndOptions = [ 785 785 + (number | _import), 786 786 + (number | _import) 787 787 + ]; 788 788 + 789 789 + export type ModelWithAnyOfConstantSizeArrayAndIntersect = [ 790 790 + (number & string), 791 791 + (number & string) 792 792 + ]; 793 793 + 794 794 + export type ModelWithNumericEnumUnion = { 795 795 + /** 796 796 + * Период 797 797 + */ 798 798 + value?: -10 | -1 | 0 | 1 | 3 | 6 | 12; 799 799 + }; 800 800 + 801 801 + /** 802 802 + * Период 803 803 + */ 804 804 + export type value = -10 | -1 | 0 | 1 | 3 | 6 | 12; 805 805 + 806 806 + /** 807 807 + * Some description with `back ticks` 808 808 + */ 809 809 + export type ModelWithBackticksInDescription = { 810 810 + /** 811 811 + * The template `that` should be used for parsing and importing the contents of the CSV file. 812 812 + * 813 813 + * <br/><p>There is one placeholder currently supported:<ul> <li><b>${x}</b> - refers to the n-th column in the CSV file, e.g. ${1}, ${2}, ...)</li></ul><p>Example of a correct JSON template:</p> 814 814 + * <pre> 815 815 + * [ 816 816 + * { 817 817 + * "resourceType": "Asset", 818 818 + * "identifier": { 819 819 + * "name": "${1}", 820 820 + * "domain": { 821 821 + * "name": "${2}", 822 822 + * "community": { 823 823 + * "name": "Some Community" 824 824 + * } 825 825 + * } 826 826 + * }, 827 827 + * "attributes" : { 828 828 + * "00000000-0000-0000-0000-000000003115" : [ { 829 829 + * "value" : "${3}" 830 830 + * } ], 831 831 + * "00000000-0000-0000-0000-000000000222" : [ { 832 832 + * "value" : "${4}" 833 833 + * } ] 834 834 + * } 835 835 + * } 836 836 + * ] 837 837 + * </pre> 838 838 + */ 839 839 + template?: string; 840 840 + }; 841 841 + 842 842 + export type ModelWithOneOfAndProperties = (ParameterSimpleParameter | NonAsciiStringæøåÆØÅöôêÊ字符串) & { 843 843 + baz: (number) | null; 844 844 + qux: number; 845 845 + }; 846 846 + 847 847 + /** 848 848 + * Model used to test deduplication strategy (unused) 849 849 + */ 850 850 + export type ParameterSimpleParameterUnused = string; 851 851 + 852 852 + /** 853 853 + * Model used to test deduplication strategy 854 854 + */ 855 855 + export type PostServiceWithEmptyTagResponse = string; 856 856 + 857 857 + /** 858 858 + * Model used to test deduplication strategy 859 859 + */ 860 860 + export type PostServiceWithEmptyTagResponse2 = string; 861 861 + 862 862 + /** 863 863 + * Model used to test deduplication strategy 864 864 + */ 865 865 + export type DeleteFooData = string; 866 866 + 867 867 + /** 868 868 + * Model used to test deduplication strategy 869 869 + */ 870 870 + export type DeleteFooData2 = string; 871 871 + 872 872 + /** 873 873 + * Model with restricted keyword name 874 874 + */ 875 875 + export type _import = string; 876 876 + 877 877 + export type SchemaWithFormRestrictedKeys = { 878 878 + description?: string; 879 879 + 'x-enum-descriptions'?: string; 880 880 + 'x-enum-varnames'?: string; 881 881 + 'x-enumNames'?: string; 882 882 + title?: string; 883 883 + object?: { 884 884 + description?: string; 885 885 + 'x-enum-descriptions'?: string; 886 886 + 'x-enum-varnames'?: string; 887 887 + 'x-enumNames'?: string; 888 888 + title?: string; 889 889 + }; 890 890 + array?: Array<({ 891 891 + description?: string; 892 892 + 'x-enum-descriptions'?: string; 893 893 + 'x-enum-varnames'?: string; 894 894 + 'x-enumNames'?: string; 895 895 + title?: string; 896 896 + })>; 897 897 + }; 898 898 + 899 899 + /** 900 900 + * This schema was giving PascalCase transformations a hard time 901 901 + */ 902 902 + export type io_k8s_apimachinery_pkg_apis_meta_v1_DeleteOptions = { 903 903 + /** 904 904 + * Must be fulfilled before a deletion is carried out. If not possible, a 409 Conflict status will be returned. 905 905 + */ 906 906 + preconditions?: (io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions); 907 907 + }; 908 908 + 909 909 + /** 910 910 + * This schema was giving PascalCase transformations a hard time 911 911 + */ 912 912 + export type io_k8s_apimachinery_pkg_apis_meta_v1_Preconditions = { 913 913 + /** 914 914 + * Specifies the target ResourceVersion 915 915 + */ 916 916 + resourceVersion?: string; 917 917 + /** 918 918 + * Specifies the target UID. 919 919 + */ 920 920 + uid?: string; 921 921 + }; 922 922 + 923 923 + export type AdditionalPropertiesUnknownIssue = { 924 924 + [key: string]: (string | number); 925 925 + }; 926 926 + 927 927 + export type AdditionalPropertiesUnknownIssue2 = { 928 928 + [key: string]: (string | number); 929 929 + }; 930 930 + 931 931 + export type AdditionalPropertiesUnknownIssue3 = string & { 932 932 + entries: { 933 933 + [key: string]: AdditionalPropertiesUnknownIssue; 934 934 + }; 935 935 + }; 936 936 + 937 937 + export type AdditionalPropertiesIntegerIssue = { 938 938 + value: number; 939 939 + [key: string]: (number) | undefined; 940 940 + }; 941 941 + 942 942 + export type OneOfAllOfIssue = ((ConstValue | Generic_Schema_Duplicate_Issue_1_System_Boolean_) & _3e_num_1Период) | Generic_Schema_Duplicate_Issue_1_System_String_; 943 943 + 944 944 + export type Generic_Schema_Duplicate_Issue_1_System_Boolean_ = { 945 945 + item?: boolean; 946 946 + error?: (string) | null; 947 947 + readonly hasError?: boolean; 948 948 + }; 949 949 + 950 950 + export type Generic_Schema_Duplicate_Issue_1_System_String_ = { 951 951 + item?: (string) | null; 952 952 + error?: (string) | null; 953 953 + readonly hasError?: boolean; 954 954 + }; 955 955 + 956 956 + /** 957 957 + * This is a reusable parameter 958 958 + */ 959 959 + export type ParameterSimpleParameter = string; 960 960 + 961 961 + /** 962 962 + * Parameter with illegal characters 963 963 + */ 964 964 + export type Parameterx_Foo_Bar = ModelWithString; 965 965 + 966 966 + export type ImportData = { 967 967 + requestBody: (ModelWithReadOnlyAndWriteOnly | ModelWithArrayReadOnlyAndWriteOnly); 968 968 + }; 969 969 + 970 970 + export type ImportResponse = (Model_From_Zendesk | ModelWithReadOnlyAndWriteOnly); 971 971 + 972 972 + export type ApiVversionOdataControllerCountResponse = (Model_From_Zendesk); 973 973 + 974 974 + export type DeleteFooData3 = { 975 975 + /** 976 976 + * bar in method 977 977 + */ 978 978 + barParam: string; 979 979 + /** 980 980 + * foo in method 981 981 + */ 982 982 + fooParam: string; 983 983 + /** 984 984 + * Parameter with illegal characters 985 985 + */ 986 986 + xFooBar: ModelWithString; 987 987 + }; 988 988 + 989 989 + export type CallWithDescriptionsData = { 990 990 + /** 991 991 + * Testing backticks in string: `backticks` and ```multiple backticks``` should work 992 992 + */ 993 993 + parameterWithBackticks?: unknown; 994 994 + /** 995 995 + * Testing multiline comments in string: First line 996 996 + * Second line 997 997 + * 998 998 + * Fourth line 999 999 + */ 1000 1000 + parameterWithBreaks?: unknown; 1001 1001 + /** 1002 1002 + * Testing expression placeholders in string: ${expression} should work 1003 1003 + */ 1004 1004 + parameterWithExpressionPlaceholders?: unknown; 1005 1005 + /** 1006 1006 + * Testing quotes in string: 'single quote''' and "double quotes""" should work 1007 1007 + */ 1008 1008 + parameterWithQuotes?: unknown; 1009 1009 + /** 1010 1010 + * Testing reserved characters in string: * inline * and ** inline ** should work 1011 1011 + */ 1012 1012 + parameterWithReservedCharacters?: unknown; 1013 1013 + /** 1014 1014 + * Testing slashes in string: \backwards\\\ and /forwards/// should work 1015 1015 + */ 1016 1016 + parameterWithSlashes?: unknown; 1017 1017 + }; 1018 1018 + 1019 1019 + export type DeprecatedCallData = { 1020 1020 + /** 1021 1021 + * This parameter is deprecated 1022 1022 + * @deprecated 1023 1023 + */ 1024 1024 + parameter: (DeprecatedModel) | null; 1025 1025 + }; 1026 1026 + 1027 1027 + export type CallWithParametersData = { 1028 1028 + /** 1029 1029 + * This is the parameter that goes into the query params 1030 1030 + */ 1031 1031 + cursor: (string) | null; 1032 1032 + fooAllOfEnum: (ModelWithNestedArrayEnumsDataFoo); 1033 1033 + fooRefEnum?: ModelWithNestedArrayEnumsDataFoo; 1034 1034 + /** 1035 1035 + * This is the parameter that goes into the cookie 1036 1036 + */ 1037 1037 + parameterCookie: (string) | null; 1038 1038 + /** 1039 1039 + * This is the parameter that goes into the header 1040 1040 + */ 1041 1041 + parameterHeader: (string) | null; 1042 1042 + /** 1043 1043 + * This is the parameter that goes into the path 1044 1044 + */ 1045 1045 + parameterPath: (string) | null; 1046 1046 + /** 1047 1047 + * This is the parameter that goes into the body 1048 1048 + */ 1049 1049 + requestBody: { 1050 1050 + [key: string]: unknown; 1051 1051 + } | null; 1052 1052 + }; 1053 1053 + 1054 1054 + export type CallWithWeirdParameterNamesData = { 1055 1055 + /** 1056 1056 + * This is the parameter with a reserved keyword 1057 1057 + */ 1058 1058 + _default?: string; 1059 1059 + /** 1060 1060 + * This is the parameter that goes into the cookie 1061 1061 + */ 1062 1062 + parameterCookie: (string) | null; 1063 1063 + /** 1064 1064 + * This is the parameter that goes into the request header 1065 1065 + */ 1066 1066 + parameterHeader: (string) | null; 1067 1067 + /** 1068 1068 + * This is the parameter that goes into the path 1069 1069 + */ 1070 1070 + parameterPath1?: string; 1071 1071 + /** 1072 1072 + * This is the parameter that goes into the path 1073 1073 + */ 1074 1074 + parameterPath2?: string; 1075 1075 + /** 1076 1076 + * This is the parameter that goes into the path 1077 1077 + */ 1078 1078 + parameterPath3?: string; 1079 1079 + /** 1080 1080 + * This is the parameter that goes into the request query params 1081 1081 + */ 1082 1082 + parameterQuery: (string) | null; 1083 1083 + /** 1084 1084 + * This is the parameter that goes into the body 1085 1085 + */ 1086 1086 + requestBody: (ModelWithString) | null; 1087 1087 + }; 1088 1088 + 1089 1089 + export type GetCallWithOptionalParamData = { 1090 1090 + /** 1091 1091 + * This is an optional parameter 1092 1092 + */ 1093 1093 + page?: number; 1094 1094 + /** 1095 1095 + * This is a required parameter 1096 1096 + */ 1097 1097 + requestBody: ModelWithOneOfEnum; 1098 1098 + }; 1099 1099 + 1100 1100 + export type PostCallWithOptionalParamData = { 1101 1101 + /** 1102 1102 + * This is a required parameter 1103 1103 + */ 1104 1104 + parameter: Pageable; 1105 1105 + /** 1106 1106 + * This is an optional parameter 1107 1107 + */ 1108 1108 + requestBody?: { 1109 1109 + offset?: (number) | null; 1110 1110 + }; 1111 1111 + }; 1112 1112 + 1113 1113 + export type PostCallWithOptionalParamResponse = (number | void); 1114 1114 + 1115 1115 + export type PostApiRequestBodyData = { 1116 1116 + /** 1117 1117 + * A reusable request body 1118 1118 + */ 1119 1119 + foo?: ModelWithString; 1120 1120 + /** 1121 1121 + * This is a reusable parameter 1122 1122 + */ 1123 1123 + parameter?: string; 1124 1124 + }; 1125 1125 + 1126 1126 + export type PostApiFormDataData = { 1127 1127 + /** 1128 1128 + * A reusable request body 1129 1129 + */ 1130 1130 + formData?: ModelWithString; 1131 1131 + /** 1132 1132 + * This is a reusable parameter 1133 1133 + */ 1134 1134 + parameter?: string; 1135 1135 + }; 1136 1136 + 1137 1137 + export type CallWithDefaultParametersData = { 1138 1138 + /** 1139 1139 + * This is a simple boolean with default value 1140 1140 + */ 1141 1141 + parameterBoolean?: (boolean) | null; 1142 1142 + /** 1143 1143 + * This is a simple enum with default value 1144 1144 + */ 1145 1145 + parameterEnum?: 'Success' | 'Warning' | 'Error'; 1146 1146 + /** 1147 1147 + * This is a simple model with default value 1148 1148 + */ 1149 1149 + parameterModel?: (ModelWithString) | null; 1150 1150 + /** 1151 1151 + * This is a simple number with default value 1152 1152 + */ 1153 1153 + parameterNumber?: (number) | null; 1154 1154 + /** 1155 1155 + * This is a simple string with default value 1156 1156 + */ 1157 1157 + parameterString?: (string) | null; 1158 1158 + }; 1159 1159 + 1160 1160 + export type CallWithDefaultOptionalParametersData = { 1161 1161 + /** 1162 1162 + * This is a simple boolean that is optional with default value 1163 1163 + */ 1164 1164 + parameterBoolean?: boolean; 1165 1165 + /** 1166 1166 + * This is a simple enum that is optional with default value 1167 1167 + */ 1168 1168 + parameterEnum?: 'Success' | 'Warning' | 'Error'; 1169 1169 + /** 1170 1170 + * This is a simple model that is optional with default value 1171 1171 + */ 1172 1172 + parameterModel?: ModelWithString; 1173 1173 + /** 1174 1174 + * This is a simple number that is optional with default value 1175 1175 + */ 1176 1176 + parameterNumber?: number; 1177 1177 + /** 1178 1178 + * This is a simple string that is optional with default value 1179 1179 + */ 1180 1180 + parameterString?: string; 1181 1181 + }; 1182 1182 + 1183 1183 + export type CallToTestOrderOfParamsData = { 1184 1184 + /** 1185 1185 + * This is a optional string with default 1186 1186 + */ 1187 1187 + parameterOptionalStringWithDefault?: string; 1188 1188 + /** 1189 1189 + * This is a optional string with empty default 1190 1190 + */ 1191 1191 + parameterOptionalStringWithEmptyDefault?: string; 1192 1192 + /** 1193 1193 + * This is a optional string with no default 1194 1194 + */ 1195 1195 + parameterOptionalStringWithNoDefault?: string; 1196 1196 + /** 1197 1197 + * This is a string that can be null with default 1198 1198 + */ 1199 1199 + parameterStringNullableWithDefault?: (string) | null; 1200 1200 + /** 1201 1201 + * This is a string that can be null with no default 1202 1202 + */ 1203 1203 + parameterStringNullableWithNoDefault?: (string) | null; 1204 1204 + /** 1205 1205 + * This is a string with default 1206 1206 + */ 1207 1207 + parameterStringWithDefault: string; 1208 1208 + /** 1209 1209 + * This is a string with empty default 1210 1210 + */ 1211 1211 + parameterStringWithEmptyDefault: string; 1212 1212 + /** 1213 1213 + * This is a string with no default 1214 1214 + */ 1215 1215 + parameterStringWithNoDefault: string; 1216 1216 + }; 1217 1217 + 1218 1218 + export type CallWithNoContentResponseResponse = (void); 1219 1219 + 1220 1220 + export type CallWithResponseAndNoContentResponseResponse = (number | void); 1221 1221 + 1222 1222 + export type DummyAResponse = (_400); 1223 1223 + 1224 1224 + export type DummyBResponse = (void); 1225 1225 + 1226 1226 + export type CallWithResponseResponse = (_import); 1227 1227 + 1228 1228 + export type CallWithDuplicateResponsesResponse = ((ModelWithBoolean & ModelWithInteger) | ModelWithString); 1229 1229 + 1230 1230 + export type CallWithResponsesResponse = ({ 1231 1231 + readonly '@namespace.string'?: string; 1232 1232 + readonly '@namespace.integer'?: number; 1233 1233 + readonly value?: Array<ModelWithString>; 1234 1234 + } | ModelThatExtends | ModelThatExtendsExtends); 1235 1235 + 1236 1236 + export type CollectionFormatData = { 1237 1237 + /** 1238 1238 + * This is an array parameter that is sent as csv format (comma-separated values) 1239 1239 + */ 1240 1240 + parameterArrayCsv: Array<(string)> | null; 1241 1241 + /** 1242 1242 + * This is an array parameter that is sent as multi format (multiple parameter instances) 1243 1243 + */ 1244 1244 + parameterArrayMulti: Array<(string)> | null; 1245 1245 + /** 1246 1246 + * This is an array parameter that is sent as pipes format (pipe-separated values) 1247 1247 + */ 1248 1248 + parameterArrayPipes: Array<(string)> | null; 1249 1249 + /** 1250 1250 + * This is an array parameter that is sent as ssv format (space-separated values) 1251 1251 + */ 1252 1252 + parameterArraySsv: Array<(string)> | null; 1253 1253 + /** 1254 1254 + * This is an array parameter that is sent as tsv format (tab-separated values) 1255 1255 + */ 1256 1256 + parameterArrayTsv: Array<(string)> | null; 1257 1257 + }; 1258 1258 + 1259 1259 + export type TypesData = { 1260 1260 + /** 1261 1261 + * This is a number parameter 1262 1262 + */ 1263 1263 + id?: number; 1264 1264 + /** 1265 1265 + * This is an array parameter 1266 1266 + */ 1267 1267 + parameterArray: Array<(string)> | null; 1268 1268 + /** 1269 1269 + * This is a boolean parameter 1270 1270 + */ 1271 1271 + parameterBoolean: (boolean) | null; 1272 1272 + /** 1273 1273 + * This is a dictionary parameter 1274 1274 + */ 1275 1275 + parameterDictionary: { 1276 1276 + [key: string]: unknown; 1277 1277 + } | null; 1278 1278 + /** 1279 1279 + * This is an enum parameter 1280 1280 + */ 1281 1281 + parameterEnum: ('Success' | 'Warning' | 'Error') | null; 1282 1282 + /** 1283 1283 + * This is a number parameter 1284 1284 + */ 1285 1285 + parameterNumber: number; 1286 1286 + /** 1287 1287 + * This is an object parameter 1288 1288 + */ 1289 1289 + parameterObject: { 1290 1290 + [key: string]: unknown; 1291 1291 + } | null; 1292 1292 + /** 1293 1293 + * This is a string parameter 1294 1294 + */ 1295 1295 + parameterString: (string) | null; 1296 1296 + }; 1297 1297 + 1298 1298 + export type TypesResponse = (number | string | boolean | { 1299 1299 + [key: string]: unknown; 1300 1300 + }); 1301 1301 + 1302 1302 + export type UploadFileData = { 1303 1303 + formData: (Blob | File); 1304 1304 + }; 1305 1305 + 1306 1306 + export type UploadFileResponse = (boolean); 1307 1307 + 1308 1308 + export type FileResponseData = { 1309 1309 + id: string; 1310 1310 + }; 1311 1311 + 1312 1312 + export type FileResponseResponse = ((Blob | File)); 1313 1313 + 1314 1314 + export type ComplexTypesData = { 1315 1315 + /** 1316 1316 + * Parameter containing object 1317 1317 + */ 1318 1318 + parameterObject: { 1319 1319 + first?: { 1320 1320 + second?: { 1321 1321 + third?: string; 1322 1322 + }; 1323 1323 + }; 1324 1324 + }; 1325 1325 + /** 1326 1326 + * Parameter containing reference 1327 1327 + */ 1328 1328 + parameterReference: ModelWithString; 1329 1329 + }; 1330 1330 + 1331 1331 + export type ComplexTypesResponse = (Array<ModelWithString>); 1332 1332 + 1333 1333 + export type MultipartRequestData = { 1334 1334 + formData?: { 1335 1335 + content?: (Blob | File); 1336 1336 + data?: ((ModelWithString) | null); 1337 1337 + }; 1338 1338 + }; 1339 1339 + 1340 1340 + export type MultipartResponseResponse = ({ 1341 1341 + file?: (Blob | File); 1342 1342 + metadata?: { 1343 1343 + foo?: string; 1344 1344 + bar?: string; 1345 1345 + }; 1346 1346 + }); 1347 1347 + 1348 1348 + export type ComplexParamsData = { 1349 1349 + id: number; 1350 1350 + requestBody?: { 1351 1351 + readonly key: (string) | null; 1352 1352 + name: (string) | null; 1353 1353 + enabled?: boolean; 1354 1354 + readonly type: 'Monkey' | 'Horse' | 'Bird'; 1355 1355 + listOfModels?: Array<ModelWithString> | null; 1356 1356 + listOfStrings?: Array<(string)> | null; 1357 1357 + parameters: (ModelWithString | ModelWithEnum | ModelWithArray | ModelWithDictionary); 1358 1358 + readonly user?: { 1359 1359 + readonly id?: number; 1360 1360 + readonly name?: (string) | null; 1361 1361 + }; 1362 1362 + }; 1363 1363 + }; 1364 1364 + 1365 1365 + export type ComplexParamsResponse = (ModelWithString); 1366 1366 + 1367 1367 + export type CallWithResultFromHeaderResponse = (string); 1368 1368 + 1369 1369 + export type TestErrorCodeData = { 1370 1370 + /** 1371 1371 + * Status code to return 1372 1372 + */ 1373 1373 + status: number; 1374 1374 + }; 1375 1375 + 1376 1376 + export type TestErrorCodeResponse = (unknown); 1377 1377 + 1378 1378 + export type NonAsciiæøåÆøÅöôêÊ字符串Data = { 1379 1379 + /** 1380 1380 + * Dummy input param 1381 1381 + */ 1382 1382 + nonAsciiParamæøåÆøÅöôêÊ: number; 1383 1383 + }; 1384 1384 + 1385 1385 + export type NonAsciiæøåÆøÅöôêÊ字符串Response = (Array<NonAsciiStringæøåÆØÅöôêÊ字符串>); 1386 1386 + 1387 1387 + export type PutWithFormUrlEncodedData = { 1388 1388 + formData: ArrayWithStrings; 1389 1389 + };

+21

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/core/ApiError.ts.snap

··· 1 1 + import type { ApiRequestOptions } from './ApiRequestOptions'; 2 2 + import type { ApiResult } from './ApiResult'; 3 3 + 4 4 + export class ApiError extends Error { 5 5 + public readonly url: string; 6 6 + public readonly status: number; 7 7 + public readonly statusText: string; 8 8 + public readonly body: unknown; 9 9 + public readonly request: ApiRequestOptions; 10 10 + 11 11 + constructor(request: ApiRequestOptions, response: ApiResult, message: string) { 12 12 + super(message); 13 13 + 14 14 + this.name = 'ApiError'; 15 15 + this.url = response.url; 16 16 + this.status = response.status; 17 17 + this.statusText = response.statusText; 18 18 + this.body = response.body; 19 19 + this.request = request; 20 20 + } 21 21 + }

+21

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/core/ApiRequestOptions.ts.snap

··· 1 1 + export type ApiRequestOptions<T = unknown> = { 2 2 + readonly body?: any; 3 3 + readonly cookies?: Record<string, unknown>; 4 4 + readonly errors?: Record<number | string, string>; 5 5 + readonly formData?: Record<string, unknown> | any[] | Blob | File; 6 6 + readonly headers?: Record<string, unknown>; 7 7 + readonly mediaType?: string; 8 8 + readonly method: 9 9 + | 'DELETE' 10 10 + | 'GET' 11 11 + | 'HEAD' 12 12 + | 'OPTIONS' 13 13 + | 'PATCH' 14 14 + | 'POST' 15 15 + | 'PUT'; 16 16 + readonly path?: Record<string, unknown>; 17 17 + readonly query?: Record<string, unknown>; 18 18 + readonly responseHeader?: string; 19 19 + readonly responseTransformer?: (data: unknown) => Promise<T>; 20 20 + readonly url: string; 21 21 + };

+7

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/core/ApiResult.ts.snap

··· 1 1 + export type ApiResult<TData = any> = { 2 2 + readonly body: TData; 3 3 + readonly ok: boolean; 4 4 + readonly status: number; 5 5 + readonly statusText: string; 6 6 + readonly url: string; 7 7 + };

+55

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/core/OpenAPI.ts.snap

··· 1 1 + import type { HttpResponse } from '@angular/common/http'; 2 2 + import type { ApiRequestOptions } from './ApiRequestOptions'; 3 3 + 4 4 + type Headers = Record<string, string>; 5 5 + type Middleware<T> = (value: T) => T | Promise<T>; 6 6 + type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>; 7 7 + 8 8 + export class Interceptors<T> { 9 9 + _fns: Middleware<T>[]; 10 10 + 11 11 + constructor() { 12 12 + this._fns = []; 13 13 + } 14 14 + 15 15 + eject(fn: Middleware<T>): void { 16 16 + const index = this._fns.indexOf(fn); 17 17 + if (index !== -1) { 18 18 + this._fns = [...this._fns.slice(0, index), ...this._fns.slice(index + 1)]; 19 19 + } 20 20 + } 21 21 + 22 22 + use(fn: Middleware<T>): void { 23 23 + this._fns = [...this._fns, fn]; 24 24 + } 25 25 + } 26 26 + 27 27 + export type OpenAPIConfig = { 28 28 + BASE: string; 29 29 + CREDENTIALS: 'include' | 'omit' | 'same-origin'; 30 30 + ENCODE_PATH?: ((path: string) => string) | undefined; 31 31 + HEADERS?: Headers | Resolver<Headers> | undefined; 32 32 + PASSWORD?: string | Resolver<string> | undefined; 33 33 + TOKEN?: string | Resolver<string> | undefined; 34 34 + USERNAME?: string | Resolver<string> | undefined; 35 35 + VERSION: string; 36 36 + WITH_CREDENTIALS: boolean; 37 37 + interceptors: { 38 38 + response: Interceptors<HttpResponse<any>>; 39 39 + }; 40 40 + }; 41 41 + 42 42 + export const OpenAPI: OpenAPIConfig = { 43 43 + BASE: 'http://localhost:3000/base', 44 44 + CREDENTIALS: 'include', 45 45 + ENCODE_PATH: undefined, 46 46 + HEADERS: undefined, 47 47 + PASSWORD: undefined, 48 48 + TOKEN: undefined, 49 49 + USERNAME: undefined, 50 50 + VERSION: '1.0', 51 51 + WITH_CREDENTIALS: false, 52 52 + interceptors: { 53 53 + response: new Interceptors(), 54 54 + }, 55 55 + };

+337

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/core/request.ts.snap

··· 1 1 + import { HttpClient, HttpHeaders } from '@angular/common/http'; 2 2 + import type { HttpResponse, HttpErrorResponse } from '@angular/common/http'; 3 3 + import { forkJoin, of, throwError } from 'rxjs'; 4 4 + import { catchError, map, switchMap } from 'rxjs/operators'; 5 5 + import type { Observable } from 'rxjs'; 6 6 + 7 7 + import { ApiError } from './ApiError'; 8 8 + import type { ApiRequestOptions } from './ApiRequestOptions'; 9 9 + import type { ApiResult } from './ApiResult'; 10 10 + import type { OpenAPIConfig } from './OpenAPI'; 11 11 + 12 12 + export const isString = (value: unknown): value is string => { 13 13 + return typeof value === 'string'; 14 14 + }; 15 15 + 16 16 + export const isStringWithValue = (value: unknown): value is string => { 17 17 + return isString(value) && value !== ''; 18 18 + }; 19 19 + 20 20 + export const isBlob = (value: any): value is Blob => { 21 21 + return value instanceof Blob; 22 22 + }; 23 23 + 24 24 + export const isFormData = (value: unknown): value is FormData => { 25 25 + return value instanceof FormData; 26 26 + }; 27 27 + 28 28 + export const base64 = (str: string): string => { 29 29 + try { 30 30 + return btoa(str); 31 31 + } catch (err) { 32 32 + // @ts-ignore 33 33 + return Buffer.from(str).toString('base64'); 34 34 + } 35 35 + }; 36 36 + 37 37 + export const getQueryString = (params: Record<string, unknown>): string => { 38 38 + const qs: string[] = []; 39 39 + 40 40 + const append = (key: string, value: unknown) => { 41 41 + qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`); 42 42 + }; 43 43 + 44 44 + const encodePair = (key: string, value: unknown) => { 45 45 + if (value === undefined || value === null) { 46 46 + return; 47 47 + } 48 48 + 49 49 + if (value instanceof Date) { 50 50 + append(key, value.toISOString()); 51 51 + } else if (Array.isArray(value)) { 52 52 + value.forEach(v => encodePair(key, v)); 53 53 + } else if (typeof value === 'object') { 54 54 + Object.entries(value).forEach(([k, v]) => encodePair(`${key}[${k}]`, v)); 55 55 + } else { 56 56 + append(key, value); 57 57 + } 58 58 + }; 59 59 + 60 60 + Object.entries(params).forEach(([key, value]) => encodePair(key, value)); 61 61 + 62 62 + return qs.length ? `?${qs.join('&')}` : ''; 63 63 + }; 64 64 + 65 65 + const getUrl = (config: OpenAPIConfig, options: ApiRequestOptions): string => { 66 66 + const encoder = config.ENCODE_PATH || encodeURI; 67 67 + 68 68 + const path = options.url 69 69 + .replace('{api-version}', config.VERSION) 70 70 + .replace(/{(.*?)}/g, (substring: string, group: string) => { 71 71 + if (options.path?.hasOwnProperty(group)) { 72 72 + return encoder(String(options.path[group])); 73 73 + } 74 74 + return substring; 75 75 + }); 76 76 + 77 77 + const url = config.BASE + path; 78 78 + return options.query ? url + getQueryString(options.query) : url; 79 79 + }; 80 80 + 81 81 + export const getFormData = (options: ApiRequestOptions): FormData | undefined => { 82 82 + if (options.formData) { 83 83 + const formData = new FormData(); 84 84 + 85 85 + const process = (key: string, value: unknown) => { 86 86 + if (isString(value) || isBlob(value)) { 87 87 + formData.append(key, value); 88 88 + } else { 89 89 + formData.append(key, JSON.stringify(value)); 90 90 + } 91 91 + }; 92 92 + 93 93 + Object.entries(options.formData) 94 94 + .filter(([, value]) => value !== undefined && value !== null) 95 95 + .forEach(([key, value]) => { 96 96 + if (Array.isArray(value)) { 97 97 + value.forEach(v => process(key, v)); 98 98 + } else { 99 99 + process(key, value); 100 100 + } 101 101 + }); 102 102 + 103 103 + return formData; 104 104 + } 105 105 + return undefined; 106 106 + }; 107 107 + 108 108 + type Resolver<T> = (options: ApiRequestOptions<T>) => Promise<T>; 109 109 + 110 110 + export const resolve = async <T>(options: ApiRequestOptions<T>, resolver?: T | Resolver<T>): Promise<T | undefined> => { 111 111 + if (typeof resolver === 'function') { 112 112 + return (resolver as Resolver<T>)(options); 113 113 + } 114 114 + return resolver; 115 115 + }; 116 116 + 117 117 + export const getHeaders = <T>(config: OpenAPIConfig, options: ApiRequestOptions<T>): Observable<HttpHeaders> => { 118 118 + return forkJoin({ 119 119 + // @ts-ignore 120 120 + token: resolve(options, config.TOKEN), 121 121 + // @ts-ignore 122 122 + username: resolve(options, config.USERNAME), 123 123 + // @ts-ignore 124 124 + password: resolve(options, config.PASSWORD), 125 125 + // @ts-ignore 126 126 + additionalHeaders: resolve(options, config.HEADERS), 127 127 + }).pipe( 128 128 + map(({ token, username, password, additionalHeaders }) => { 129 129 + const headers = Object.entries({ 130 130 + Accept: 'application/json', 131 131 + ...additionalHeaders, 132 132 + ...options.headers, 133 133 + }) 134 134 + .filter(([, value]) => value !== undefined && value !== null) 135 135 + .reduce((headers, [key, value]) => ({ 136 136 + ...headers, 137 137 + [key]: String(value), 138 138 + }), {} as Record<string, string>); 139 139 + 140 140 + if (isStringWithValue(token)) { 141 141 + headers['Authorization'] = `Bearer ${token}`; 142 142 + } 143 143 + 144 144 + if (isStringWithValue(username) && isStringWithValue(password)) { 145 145 + const credentials = base64(`${username}:${password}`); 146 146 + headers['Authorization'] = `Basic ${credentials}`; 147 147 + } 148 148 + 149 149 + if (options.body !== undefined) { 150 150 + if (options.mediaType) { 151 151 + headers['Content-Type'] = options.mediaType; 152 152 + } else if (isBlob(options.body)) { 153 153 + headers['Content-Type'] = options.body.type || 'application/octet-stream'; 154 154 + } else if (isString(options.body)) { 155 155 + headers['Content-Type'] = 'text/plain'; 156 156 + } else if (!isFormData(options.body)) { 157 157 + headers['Content-Type'] = 'application/json'; 158 158 + } 159 159 + } 160 160 + 161 161 + return new HttpHeaders(headers); 162 162 + }), 163 163 + ); 164 164 + }; 165 165 + 166 166 + export const getRequestBody = (options: ApiRequestOptions): unknown => { 167 167 + if (options.body) { 168 168 + if (options.mediaType?.includes('application/json') || options.mediaType?.includes('+json')) { 169 169 + return JSON.stringify(options.body); 170 170 + } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) { 171 171 + return options.body; 172 172 + } else { 173 173 + return JSON.stringify(options.body); 174 174 + } 175 175 + } 176 176 + return undefined; 177 177 + }; 178 178 + 179 179 + export const sendRequest = <T>( 180 180 + config: OpenAPIConfig, 181 181 + options: ApiRequestOptions<T>, 182 182 + http: HttpClient, 183 183 + url: string, 184 184 + body: unknown, 185 185 + formData: FormData | undefined, 186 186 + headers: HttpHeaders 187 187 + ): Observable<HttpResponse<T>> => { 188 188 + return http.request<T>(options.method, url, { 189 189 + headers, 190 190 + body: body ?? formData, 191 191 + withCredentials: config.WITH_CREDENTIALS, 192 192 + observe: 'response', 193 193 + }); 194 194 + }; 195 195 + 196 196 + export const getResponseHeader = <T>(response: HttpResponse<T>, responseHeader?: string): string | undefined => { 197 197 + if (responseHeader) { 198 198 + const value = response.headers.get(responseHeader); 199 199 + if (isString(value)) { 200 200 + return value; 201 201 + } 202 202 + } 203 203 + return undefined; 204 204 + }; 205 205 + 206 206 + export const getResponseBody = <T>(response: HttpResponse<T>): T | undefined => { 207 207 + if (response.status !== 204 && response.body !== null) { 208 208 + return response.body; 209 209 + } 210 210 + return undefined; 211 211 + }; 212 212 + 213 213 + export const catchErrorCodes = (options: ApiRequestOptions, result: ApiResult): void => { 214 214 + const errors: Record<number, string> = { 215 215 + 400: 'Bad Request', 216 216 + 401: 'Unauthorized', 217 217 + 402: 'Payment Required', 218 218 + 403: 'Forbidden', 219 219 + 404: 'Not Found', 220 220 + 405: 'Method Not Allowed', 221 221 + 406: 'Not Acceptable', 222 222 + 407: 'Proxy Authentication Required', 223 223 + 408: 'Request Timeout', 224 224 + 409: 'Conflict', 225 225 + 410: 'Gone', 226 226 + 411: 'Length Required', 227 227 + 412: 'Precondition Failed', 228 228 + 413: 'Payload Too Large', 229 229 + 414: 'URI Too Long', 230 230 + 415: 'Unsupported Media Type', 231 231 + 416: 'Range Not Satisfiable', 232 232 + 417: 'Expectation Failed', 233 233 + 418: 'Im a teapot', 234 234 + 421: 'Misdirected Request', 235 235 + 422: 'Unprocessable Content', 236 236 + 423: 'Locked', 237 237 + 424: 'Failed Dependency', 238 238 + 425: 'Too Early', 239 239 + 426: 'Upgrade Required', 240 240 + 428: 'Precondition Required', 241 241 + 429: 'Too Many Requests', 242 242 + 431: 'Request Header Fields Too Large', 243 243 + 451: 'Unavailable For Legal Reasons', 244 244 + 500: 'Internal Server Error', 245 245 + 501: 'Not Implemented', 246 246 + 502: 'Bad Gateway', 247 247 + 503: 'Service Unavailable', 248 248 + 504: 'Gateway Timeout', 249 249 + 505: 'HTTP Version Not Supported', 250 250 + 506: 'Variant Also Negotiates', 251 251 + 507: 'Insufficient Storage', 252 252 + 508: 'Loop Detected', 253 253 + 510: 'Not Extended', 254 254 + 511: 'Network Authentication Required', 255 255 + ...options.errors, 256 256 + } 257 257 + 258 258 + const error = errors[result.status]; 259 259 + if (error) { 260 260 + throw new ApiError(options, result, error); 261 261 + } 262 262 + 263 263 + if (!result.ok) { 264 264 + const errorStatus = result.status ?? 'unknown'; 265 265 + const errorStatusText = result.statusText ?? 'unknown'; 266 266 + const errorBody = (() => { 267 267 + try { 268 268 + return JSON.stringify(result.body, null, 2); 269 269 + } catch (e) { 270 270 + return undefined; 271 271 + } 272 272 + })(); 273 273 + 274 274 + throw new ApiError(options, result, 275 275 + `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}` 276 276 + ); 277 277 + } 278 278 + }; 279 279 + 280 280 + /** 281 281 + * Request method 282 282 + * @param config The OpenAPI configuration object 283 283 + * @param http The Angular HTTP client 284 284 + * @param options The request options from the service 285 285 + * @returns Observable<T> 286 286 + * @throws ApiError 287 287 + */ 288 288 + export const request = <T>(config: OpenAPIConfig, http: HttpClient, options: ApiRequestOptions<T>): Observable<T> => { 289 289 + const url = getUrl(config, options); 290 290 + const formData = getFormData(options); 291 291 + const body = getRequestBody(options); 292 292 + 293 293 + return getHeaders(config, options).pipe( 294 294 + switchMap(headers => { 295 295 + return sendRequest<T>(config, options, http, url, body, formData, headers); 296 296 + }), 297 297 + switchMap(async response => { 298 298 + for (const fn of config.interceptors.response._fns) { 299 299 + response = await fn(response); 300 300 + } 301 301 + const responseBody = getResponseBody(response); 302 302 + const responseHeader = getResponseHeader(response, options.responseHeader); 303 303 + 304 304 + let transformedBody = responseBody; 305 305 + if (options.responseTransformer && response.ok) { 306 306 + transformedBody = await options.responseTransformer(responseBody) 307 307 + } 308 308 + 309 309 + return { 310 310 + url, 311 311 + ok: response.ok, 312 312 + status: response.status, 313 313 + statusText: response.statusText, 314 314 + body: responseHeader ?? transformedBody, 315 315 + } as ApiResult; 316 316 + }), 317 317 + catchError((error: HttpErrorResponse) => { 318 318 + if (!error.status) { 319 319 + return throwError(() => error); 320 320 + } 321 321 + return of({ 322 322 + url, 323 323 + ok: error.ok, 324 324 + status: error.status, 325 325 + statusText: error.statusText, 326 326 + body: error.error ?? error.statusText, 327 327 + } as ApiResult); 328 328 + }), 329 329 + map(result => { 330 330 + catchErrorCodes(options, result); 331 331 + return result.body as T; 332 332 + }), 333 333 + catchError((error: ApiError) => { 334 334 + return throwError(() => error); 335 335 + }), 336 336 + ); 337 337 + };

+5

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/index.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + export { ApiError } from './core/ApiError'; 3 3 + export { OpenAPI, type OpenAPIConfig } from './core/OpenAPI'; 4 4 + export * from './services.gen'; 5 5 + export * from './types.gen';

+67

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/services.gen.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + 3 3 + import { Injectable } from '@angular/core'; 4 4 + import { HttpClient } from '@angular/common/http'; 5 5 + import type { Observable } from 'rxjs'; 6 6 + import { OpenAPI } from './core/OpenAPI'; 7 7 + import { request as __request } from './core/request'; 8 8 + import { type ParentModelWithDatesResponse, type ModelWithDatesResponse, type ModelWithDatesArrayResponse, type ArrayOfDatesResponse, type DateResponse, type MultipleResponsesResponse, ParentModelWithDatesResponseTransformer, ModelWithDatesResponseTransformer, ModelWithDatesArrayResponseTransformer } from './types.gen'; 9 9 + 10 10 + /** 11 11 + * @returns ParentModelWithDates Success 12 12 + * @returns unknown Success 13 13 + * @throws ApiError 14 14 + */ 15 15 + export const parentModelWithDates = function (): Observable<ParentModelWithDatesResponse> { return __request(OpenAPI, this.http, { 16 16 + method: 'POST', 17 17 + url: '/api/model-with-dates', 18 18 + responseTransformer: ParentModelWithDatesResponseTransformer 19 19 + }); }; 20 20 + 21 21 + /** 22 22 + * @returns ModelWithDates Success 23 23 + * @throws ApiError 24 24 + */ 25 25 + export const modelWithDates = function (): Observable<ModelWithDatesResponse> { return __request(OpenAPI, this.http, { 26 26 + method: 'PUT', 27 27 + url: '/api/model-with-dates', 28 28 + responseTransformer: ModelWithDatesResponseTransformer 29 29 + }); }; 30 30 + 31 31 + /** 32 32 + * @returns ModelWithDates Success 33 33 + * @throws ApiError 34 34 + */ 35 35 + export const modelWithDatesArray = function (): Observable<ModelWithDatesArrayResponse> { return __request(OpenAPI, this.http, { 36 36 + method: 'PUT', 37 37 + url: '/api/model-with-dates-array', 38 38 + responseTransformer: ModelWithDatesArrayResponseTransformer 39 39 + }); }; 40 40 + 41 41 + /** 42 42 + * @returns string Success 43 43 + * @throws ApiError 44 44 + */ 45 45 + export const arrayOfDates = function (): Observable<ArrayOfDatesResponse> { return __request(OpenAPI, this.http, { 46 46 + method: 'PUT', 47 47 + url: '/api/array-of-dates' 48 48 + }); }; 49 49 + 50 50 + /** 51 51 + * @returns string Success 52 52 + * @throws ApiError 53 53 + */ 54 54 + export const date = function (): Observable<DateResponse> { return __request(OpenAPI, this.http, { 55 55 + method: 'PUT', 56 56 + url: '/api/date' 57 57 + }); }; 58 58 + 59 59 + /** 60 60 + * @returns ModelWithDates Updated 61 61 + * @returns SimpleModel Created 62 62 + * @throws ApiError 63 63 + */ 64 64 + export const multipleResponses = function (): Observable<MultipleResponsesResponse> { return __request(OpenAPI, this.http, { 65 65 + method: 'PUT', 66 66 + url: '/api/multiple-responses' 67 67 + }); };

+102

packages/openapi-ts/test/__snapshots__/test/generated/v3_angular_tree_shakeable_transform/types.gen.ts.snap

··· 1 1 + // This file is auto-generated by @hey-api/openapi-ts 2 2 + 3 3 + /** 4 4 + * This is a model that contains a some dates 5 5 + */ 6 6 + export type SimpleModel = { 7 7 + id: number; 8 8 + name: string; 9 9 + readonly enabled: boolean; 10 10 + }; 11 11 + 12 12 + /** 13 13 + * This is a model that contains a some dates 14 14 + */ 15 15 + export type ModelWithDates = { 16 16 + id: number; 17 17 + name: string; 18 18 + readonly enabled: boolean; 19 19 + readonly modified: Date; 20 20 + readonly expires?: Date; 21 21 + }; 22 22 + 23 23 + /** 24 24 + * This is a model that contains a some dates and arrays 25 25 + */ 26 26 + export type ParentModelWithDates = { 27 27 + id: number; 28 28 + readonly modified?: Date; 29 29 + items?: Array<ModelWithDates>; 30 30 + item?: ModelWithDates; 31 31 + simpleItems?: Array<SimpleModel>; 32 32 + simpleItem?: SimpleModel; 33 33 + dates?: Array<(Date)>; 34 34 + strings?: Array<(string)>; 35 35 + }; 36 36 + 37 37 + export type ParentModelWithDatesResponse = (ParentModelWithDates | unknown); 38 38 + 39 39 + export type ModelWithDatesResponse = (ModelWithDates); 40 40 + 41 41 + export type ModelWithDatesArrayResponse = (Array<ModelWithDates>); 42 42 + 43 43 + export type ArrayOfDatesResponse = (Array<(Date)>); 44 44 + 45 45 + export type DateResponse = (Date); 46 46 + 47 47 + export type MultipleResponsesResponse = (Array<ModelWithDates> | Array<SimpleModel>); 48 48 + 49 49 + export type ParentModelWithDatesResponseTransformer = (data: any) => Promise<ParentModelWithDatesResponse>; 50 50 + 51 51 + export type ParentModelWithDatesModelResponseTransformer = (data: any) => ParentModelWithDates; 52 52 + 53 53 + export type ModelWithDatesModelResponseTransformer = (data: any) => ModelWithDates; 54 54 + 55 55 + export const ModelWithDatesModelResponseTransformer: ModelWithDatesModelResponseTransformer = data => { 56 56 + if (data?.modified) { 57 57 + data.modified = new Date(data.modified); 58 58 + } 59 59 + if (data?.expires) { 60 60 + data.expires = new Date(data.expires); 61 61 + } 62 62 + return data; 63 63 + }; 64 64 + 65 65 + export const ParentModelWithDatesModelResponseTransformer: ParentModelWithDatesModelResponseTransformer = data => { 66 66 + if (data?.modified) { 67 67 + data.modified = new Date(data.modified); 68 68 + } 69 69 + if (Array.isArray(data?.items)) { 70 70 + data.items.forEach(ModelWithDatesModelResponseTransformer); 71 71 + } 72 72 + if (data?.item) { 73 73 + ModelWithDatesModelResponseTransformer(data.item); 74 74 + } 75 75 + if (Array.isArray(data?.dates)) { 76 76 + data.dates = data.dates.map(item => new Date(item)); 77 77 + } 78 78 + return data; 79 79 + }; 80 80 + 81 81 + export const ParentModelWithDatesResponseTransformer: ParentModelWithDatesResponseTransformer = async (data) => { 82 82 + if (data) { 83 83 + ParentModelWithDatesModelResponseTransformer(data); 84 84 + } 85 85 + return data; 86 86 + }; 87 87 + 88 88 + export type ModelWithDatesResponseTransformer = (data: any) => Promise<ModelWithDatesResponse>; 89 89 + 90 90 + export const ModelWithDatesResponseTransformer: ModelWithDatesResponseTransformer = async (data) => { 91 91 + ModelWithDatesModelResponseTransformer(data); 92 92 + return data; 93 93 + }; 94 94 + 95 95 + export type ModelWithDatesArrayResponseTransformer = (data: any) => Promise<ModelWithDatesArrayResponse>; 96 96 + 97 97 + export const ModelWithDatesArrayResponseTransformer: ModelWithDatesArrayResponseTransformer = async (data) => { 98 98 + if (Array.isArray(data)) { 99 99 + data.forEach(ModelWithDatesModelResponseTransformer); 100 100 + } 101 101 + return data; 102 102 + };

+8

packages/openapi-ts/test/index.spec.ts

··· 92 92 }, 93 93 { 94 94 config: createConfig({ 95 95 + client: 'angular', 96 96 + types: {}, 97 97 + }), 98 98 + description: 'generate tree-shakeable angular client', 99 99 + name: 'v3_angular_tree_shakeable', 100 100 + }, 101 101 + { 102 102 + config: createConfig({ 95 103 client: 'node', 96 104 services: { 97 105 asClass: true,