@nestia/sdk 4.0.0-dev.20241021 → 4.0.0-dev.20241021-2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. package/assets/bundle/api/Primitive.ts +1 -1
  2. package/assets/bundle/api/Resolved.ts +1 -1
  3. package/lib/executable/internal/NestiaConfigLoader.js +126 -126
  4. package/lib/generates/SdkGenerator.js +14 -1
  5. package/lib/generates/SdkGenerator.js.map +1 -1
  6. package/lib/generates/SwaggerGenerator.js +12 -12
  7. package/lib/generates/internal/SdkAliasCollection.js +4 -4
  8. package/lib/generates/internal/SdkAliasCollection.js.map +1 -1
  9. package/lib/generates/internal/SdkDistributionComposer.js +6 -6
  10. package/lib/generates/internal/SdkImportWizard.js +2 -2
  11. package/lib/generates/internal/SdkImportWizard.js.map +1 -1
  12. package/package.json +7 -7
  13. package/src/generates/SdkGenerator.ts +14 -1
  14. package/src/generates/internal/SdkAliasCollection.ts +4 -4
  15. package/src/generates/internal/SdkImportWizard.ts +2 -2
package/lib/executable/internal/NestiaConfigLoader.js CHANGED
@@ -36,8 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
36
36
  };
37
37
  Object.defineProperty(exports, "__esModule", { value: true });
38
38
  exports.NestiaConfigLoader = void 0;
39
- const __$assertGuard = __importStar(require("typia/lib/internal/$assertGuard.js"));
40
- const __$accessExpressionAsString = __importStar(require("typia/lib/internal/$accessExpressionAsString.js"));
39
+ const __typia_transform_$assertGuard = __importStar(require("typia/lib/internal/$assertGuard.js"));
40
+ const __typia_transform_$accessExpressionAsString = __importStar(require("typia/lib/internal/$accessExpressionAsString.js"));
41
41
  const NoTransformConfigurationError_1 = require("@nestia/core/lib/decorators/NoTransformConfigurationError");
42
42
  const fs_1 = __importDefault(require("fs"));
43
43
  const path_1 = __importDefault(require("path"));
@@ -65,22 +65,22 @@ var NestiaConfigLoader;
65
65
  ...(() => { const $io0 = input => true; const $ao0 = (input, _path, _exceptionable = true) => true; const __is = input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && $io0(elem)); let _errorFactory; return (input, errorFactory) => {
66
66
  if (false === __is(input)) {
67
67
  _errorFactory = errorFactory;
68
- ((input, _path, _exceptionable = true) => (Array.isArray(input) || __$assertGuard.$assertGuard(true, {
68
+ ((input, _path, _exceptionable = true) => (Array.isArray(input) || __typia_transform_$assertGuard.$assertGuard(true, {
69
69
  method: "typia\r\n .assert",
70
70
  path: _path + "",
71
71
  expected: "Array<object>",
72
72
  value: input
73
- }, _errorFactory)) && input.every((elem, _index2) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || __$assertGuard.$assertGuard(true, {
73
+ }, _errorFactory)) && input.every((elem, _index2) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || __typia_transform_$assertGuard.$assertGuard(true, {
74
74
  method: "typia\r\n .assert",
75
75
  path: _path + "[" + _index2 + "]",
76
76
  expected: "object",
77
77
  value: elem
78
- }, _errorFactory)) && $ao0(elem, _path + "[" + _index2 + "]", true) || __$assertGuard.$assertGuard(true, {
78
+ }, _errorFactory)) && $ao0(elem, _path + "[" + _index2 + "]", true) || __typia_transform_$assertGuard.$assertGuard(true, {
79
79
  method: "typia\r\n .assert",
80
80
  path: _path + "[" + _index2 + "]",
81
81
  expected: "object",
82
82
  value: elem
83
- }, _errorFactory)) || __$assertGuard.$assertGuard(true, {
83
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(true, {
84
84
  method: "typia\r\n .assert",
85
85
  path: _path + "",
86
86
  expected: "Array<object>",
@@ -134,297 +134,297 @@ var NestiaConfigLoader;
134
134
  return $io19(input);
135
135
  else
136
136
  return false;
137
- })(); const $ao0 = (input, _path, _exceptionable = true) => (null !== input.input || __$assertGuard.$assertGuard(_exceptionable, {
137
+ })(); const $ao0 = (input, _path, _exceptionable = true) => (null !== input.input || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
138
138
  method: "typia.assert",
139
139
  path: _path + ".input",
140
140
  expected: "(Array<string> | INestiaConfig.IInput | string)",
141
141
  value: input.input
142
- }, _errorFactory)) && (undefined !== input.input || __$assertGuard.$assertGuard(_exceptionable, {
142
+ }, _errorFactory)) && (undefined !== input.input || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
143
143
  method: "typia.assert",
144
144
  path: _path + ".input",
145
145
  expected: "(Array<string> | INestiaConfig.IInput | string)",
146
146
  value: input.input
147
- }, _errorFactory)) && ("function" === typeof input.input || "string" === typeof input.input || (Array.isArray(input.input) && input.input.every((elem, _index9) => "string" === typeof elem || __$assertGuard.$assertGuard(_exceptionable, {
147
+ }, _errorFactory)) && ("function" === typeof input.input || "string" === typeof input.input || (Array.isArray(input.input) && input.input.every((elem, _index9) => "string" === typeof elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
148
148
  method: "typia.assert",
149
149
  path: _path + ".input[" + _index9 + "]",
150
150
  expected: "string",
151
151
  value: elem
152
- }, _errorFactory)) || "object" === typeof input.input && null !== input.input && $ao1(input.input, _path + ".input", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
152
+ }, _errorFactory)) || "object" === typeof input.input && null !== input.input && $ao1(input.input, _path + ".input", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
153
153
  method: "typia.assert",
154
154
  path: _path + ".input",
155
155
  expected: "(Array<string> | INestiaConfig.IInput | string)",
156
156
  value: input.input
157
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
157
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
158
158
  method: "typia.assert",
159
159
  path: _path + ".input",
160
160
  expected: "(Array<string> | INestiaConfig.IInput | string)",
161
161
  value: input.input
162
- }, _errorFactory)) && (undefined === input.swagger || ("object" === typeof input.swagger && null !== input.swagger || __$assertGuard.$assertGuard(_exceptionable, {
162
+ }, _errorFactory)) && (undefined === input.swagger || ("object" === typeof input.swagger && null !== input.swagger || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
163
163
  method: "typia.assert",
164
164
  path: _path + ".swagger",
165
165
  expected: "(INestiaConfig.ISwaggerConfig | undefined)",
166
166
  value: input.swagger
167
- }, _errorFactory)) && $ao2(input.swagger, _path + ".swagger", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
167
+ }, _errorFactory)) && $ao2(input.swagger, _path + ".swagger", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
168
168
  method: "typia.assert",
169
169
  path: _path + ".swagger",
170
170
  expected: "(INestiaConfig.ISwaggerConfig | undefined)",
171
171
  value: input.swagger
172
- }, _errorFactory)) && (undefined === input.output || "string" === typeof input.output || __$assertGuard.$assertGuard(_exceptionable, {
172
+ }, _errorFactory)) && (undefined === input.output || "string" === typeof input.output || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
173
173
  method: "typia.assert",
174
174
  path: _path + ".output",
175
175
  expected: "(string | undefined)",
176
176
  value: input.output
177
- }, _errorFactory)) && (undefined === input.distribute || "string" === typeof input.distribute || __$assertGuard.$assertGuard(_exceptionable, {
177
+ }, _errorFactory)) && (undefined === input.distribute || "string" === typeof input.distribute || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
178
178
  method: "typia.assert",
179
179
  path: _path + ".distribute",
180
180
  expected: "(string | undefined)",
181
181
  value: input.distribute
182
- }, _errorFactory)) && (undefined === input.simulate || "boolean" === typeof input.simulate || __$assertGuard.$assertGuard(_exceptionable, {
182
+ }, _errorFactory)) && (undefined === input.simulate || "boolean" === typeof input.simulate || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
183
183
  method: "typia.assert",
184
184
  path: _path + ".simulate",
185
185
  expected: "(boolean | undefined)",
186
186
  value: input.simulate
187
- }, _errorFactory)) && (undefined === input.e2e || "string" === typeof input.e2e || __$assertGuard.$assertGuard(_exceptionable, {
187
+ }, _errorFactory)) && (undefined === input.e2e || "string" === typeof input.e2e || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
188
188
  method: "typia.assert",
189
189
  path: _path + ".e2e",
190
190
  expected: "(string | undefined)",
191
191
  value: input.e2e
192
- }, _errorFactory)) && (undefined === input.propagate || "boolean" === typeof input.propagate || __$assertGuard.$assertGuard(_exceptionable, {
192
+ }, _errorFactory)) && (undefined === input.propagate || "boolean" === typeof input.propagate || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
193
193
  method: "typia.assert",
194
194
  path: _path + ".propagate",
195
195
  expected: "(boolean | undefined)",
196
196
  value: input.propagate
197
- }, _errorFactory)) && (undefined === input.clone || "boolean" === typeof input.clone || __$assertGuard.$assertGuard(_exceptionable, {
197
+ }, _errorFactory)) && (undefined === input.clone || "boolean" === typeof input.clone || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
198
198
  method: "typia.assert",
199
199
  path: _path + ".clone",
200
200
  expected: "(boolean | undefined)",
201
201
  value: input.clone
202
- }, _errorFactory)) && (undefined === input.primitive || "boolean" === typeof input.primitive || __$assertGuard.$assertGuard(_exceptionable, {
202
+ }, _errorFactory)) && (undefined === input.primitive || "boolean" === typeof input.primitive || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
203
203
  method: "typia.assert",
204
204
  path: _path + ".primitive",
205
205
  expected: "(boolean | undefined)",
206
206
  value: input.primitive
207
- }, _errorFactory)) && (undefined === input.assert || "boolean" === typeof input.assert || __$assertGuard.$assertGuard(_exceptionable, {
207
+ }, _errorFactory)) && (undefined === input.assert || "boolean" === typeof input.assert || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
208
208
  method: "typia.assert",
209
209
  path: _path + ".assert",
210
210
  expected: "(boolean | undefined)",
211
211
  value: input.assert
212
- }, _errorFactory)) && (undefined === input.json || "boolean" === typeof input.json || __$assertGuard.$assertGuard(_exceptionable, {
212
+ }, _errorFactory)) && (undefined === input.json || "boolean" === typeof input.json || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
213
213
  method: "typia.assert",
214
214
  path: _path + ".json",
215
215
  expected: "(boolean | undefined)",
216
216
  value: input.json
217
- }, _errorFactory)); const $ao1 = (input, _path, _exceptionable = true) => ((Array.isArray(input.include) || __$assertGuard.$assertGuard(_exceptionable, {
217
+ }, _errorFactory)); const $ao1 = (input, _path, _exceptionable = true) => ((Array.isArray(input.include) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
218
218
  method: "typia.assert",
219
219
  path: _path + ".include",
220
220
  expected: "Array<string>",
221
221
  value: input.include
222
- }, _errorFactory)) && input.include.every((elem, _index10) => "string" === typeof elem || __$assertGuard.$assertGuard(_exceptionable, {
222
+ }, _errorFactory)) && input.include.every((elem, _index10) => "string" === typeof elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
223
223
  method: "typia.assert",
224
224
  path: _path + ".include[" + _index10 + "]",
225
225
  expected: "string",
226
226
  value: elem
227
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
227
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
228
228
  method: "typia.assert",
229
229
  path: _path + ".include",
230
230
  expected: "Array<string>",
231
231
  value: input.include
232
- }, _errorFactory)) && (undefined === input.exclude || (Array.isArray(input.exclude) || __$assertGuard.$assertGuard(_exceptionable, {
232
+ }, _errorFactory)) && (undefined === input.exclude || (Array.isArray(input.exclude) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
233
233
  method: "typia.assert",
234
234
  path: _path + ".exclude",
235
235
  expected: "(Array<string> | undefined)",
236
236
  value: input.exclude
237
- }, _errorFactory)) && input.exclude.every((elem, _index11) => "string" === typeof elem || __$assertGuard.$assertGuard(_exceptionable, {
237
+ }, _errorFactory)) && input.exclude.every((elem, _index11) => "string" === typeof elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
238
238
  method: "typia.assert",
239
239
  path: _path + ".exclude[" + _index11 + "]",
240
240
  expected: "string",
241
241
  value: elem
242
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
242
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
243
243
  method: "typia.assert",
244
244
  path: _path + ".exclude",
245
245
  expected: "(Array<string> | undefined)",
246
246
  value: input.exclude
247
- }, _errorFactory)); const $ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.output || __$assertGuard.$assertGuard(_exceptionable, {
247
+ }, _errorFactory)); const $ao2 = (input, _path, _exceptionable = true) => ("string" === typeof input.output || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
248
248
  method: "typia.assert",
249
249
  path: _path + ".output",
250
250
  expected: "string",
251
251
  value: input.output
252
- }, _errorFactory)) && (undefined === input.openapi || "2.0" === input.openapi || "3.0" === input.openapi || "3.1" === input.openapi || __$assertGuard.$assertGuard(_exceptionable, {
252
+ }, _errorFactory)) && (undefined === input.openapi || "2.0" === input.openapi || "3.0" === input.openapi || "3.1" === input.openapi || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
253
253
  method: "typia.assert",
254
254
  path: _path + ".openapi",
255
255
  expected: "(\"2.0\" | \"3.0\" | \"3.1\" | undefined)",
256
256
  value: input.openapi
257
- }, _errorFactory)) && (undefined === input.beautify || "number" === typeof input.beautify || "boolean" === typeof input.beautify || __$assertGuard.$assertGuard(_exceptionable, {
257
+ }, _errorFactory)) && (undefined === input.beautify || "number" === typeof input.beautify || "boolean" === typeof input.beautify || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
258
258
  method: "typia.assert",
259
259
  path: _path + ".beautify",
260
260
  expected: "(boolean | number | undefined)",
261
261
  value: input.beautify
262
- }, _errorFactory)) && (undefined === input.additional || "boolean" === typeof input.additional || __$assertGuard.$assertGuard(_exceptionable, {
262
+ }, _errorFactory)) && (undefined === input.additional || "boolean" === typeof input.additional || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
263
263
  method: "typia.assert",
264
264
  path: _path + ".additional",
265
265
  expected: "(boolean | undefined)",
266
266
  value: input.additional
267
- }, _errorFactory)) && (undefined === input.info || ("object" === typeof input.info && null !== input.info && false === Array.isArray(input.info) || __$assertGuard.$assertGuard(_exceptionable, {
267
+ }, _errorFactory)) && (undefined === input.info || ("object" === typeof input.info && null !== input.info && false === Array.isArray(input.info) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
268
268
  method: "typia.assert",
269
269
  path: _path + ".info",
270
270
  expected: "(Partial<OpenApi.IDocument.IInfo> | undefined)",
271
271
  value: input.info
272
- }, _errorFactory)) && $ao3(input.info, _path + ".info", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
272
+ }, _errorFactory)) && $ao3(input.info, _path + ".info", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
273
273
  method: "typia.assert",
274
274
  path: _path + ".info",
275
275
  expected: "(Partial<OpenApi.IDocument.IInfo> | undefined)",
276
276
  value: input.info
277
- }, _errorFactory)) && (undefined === input.servers || (Array.isArray(input.servers) || __$assertGuard.$assertGuard(_exceptionable, {
277
+ }, _errorFactory)) && (undefined === input.servers || (Array.isArray(input.servers) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
278
278
  method: "typia.assert",
279
279
  path: _path + ".servers",
280
280
  expected: "(Array<OpenApi.IServer> | undefined)",
281
281
  value: input.servers
282
- }, _errorFactory)) && input.servers.every((elem, _index12) => ("object" === typeof elem && null !== elem || __$assertGuard.$assertGuard(_exceptionable, {
282
+ }, _errorFactory)) && input.servers.every((elem, _index12) => ("object" === typeof elem && null !== elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
283
283
  method: "typia.assert",
284
284
  path: _path + ".servers[" + _index12 + "]",
285
285
  expected: "OpenApi.IServer",
286
286
  value: elem
287
- }, _errorFactory)) && $ao6(elem, _path + ".servers[" + _index12 + "]", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
287
+ }, _errorFactory)) && $ao6(elem, _path + ".servers[" + _index12 + "]", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
288
288
  method: "typia.assert",
289
289
  path: _path + ".servers[" + _index12 + "]",
290
290
  expected: "OpenApi.IServer",
291
291
  value: elem
292
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
292
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
293
293
  method: "typia.assert",
294
294
  path: _path + ".servers",
295
295
  expected: "(Array<OpenApi.IServer> | undefined)",
296
296
  value: input.servers
297
- }, _errorFactory)) && (undefined === input.security || ("object" === typeof input.security && null !== input.security && false === Array.isArray(input.security) || __$assertGuard.$assertGuard(_exceptionable, {
297
+ }, _errorFactory)) && (undefined === input.security || ("object" === typeof input.security && null !== input.security && false === Array.isArray(input.security) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
298
298
  method: "typia.assert",
299
299
  path: _path + ".security",
300
300
  expected: "(Record<string, OpenApi.ISecurityScheme> | undefined)",
301
301
  value: input.security
302
- }, _errorFactory)) && $ao9(input.security, _path + ".security", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
302
+ }, _errorFactory)) && $ao9(input.security, _path + ".security", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
303
303
  method: "typia.assert",
304
304
  path: _path + ".security",
305
305
  expected: "(Record<string, OpenApi.ISecurityScheme> | undefined)",
306
306
  value: input.security
307
- }, _errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || __$assertGuard.$assertGuard(_exceptionable, {
307
+ }, _errorFactory)) && (undefined === input.tags || (Array.isArray(input.tags) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
308
308
  method: "typia.assert",
309
309
  path: _path + ".tags",
310
310
  expected: "(Array<OpenApi.IDocument.ITag> | undefined)",
311
311
  value: input.tags
312
- }, _errorFactory)) && input.tags.every((elem, _index13) => ("object" === typeof elem && null !== elem || __$assertGuard.$assertGuard(_exceptionable, {
312
+ }, _errorFactory)) && input.tags.every((elem, _index13) => ("object" === typeof elem && null !== elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
313
313
  method: "typia.assert",
314
314
  path: _path + ".tags[" + _index13 + "]",
315
315
  expected: "OpenApi.IDocument.ITag",
316
316
  value: elem
317
- }, _errorFactory)) && $ao20(elem, _path + ".tags[" + _index13 + "]", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
317
+ }, _errorFactory)) && $ao20(elem, _path + ".tags[" + _index13 + "]", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
318
318
  method: "typia.assert",
319
319
  path: _path + ".tags[" + _index13 + "]",
320
320
  expected: "OpenApi.IDocument.ITag",
321
321
  value: elem
322
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
322
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
323
323
  method: "typia.assert",
324
324
  path: _path + ".tags",
325
325
  expected: "(Array<OpenApi.IDocument.ITag> | undefined)",
326
326
  value: input.tags
327
- }, _errorFactory)) && (undefined === input.decompose || "boolean" === typeof input.decompose || __$assertGuard.$assertGuard(_exceptionable, {
327
+ }, _errorFactory)) && (undefined === input.decompose || "boolean" === typeof input.decompose || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
328
328
  method: "typia.assert",
329
329
  path: _path + ".decompose",
330
330
  expected: "(boolean | undefined)",
331
331
  value: input.decompose
332
- }, _errorFactory)); const $ao3 = (input, _path, _exceptionable = true) => (undefined === input.title || "string" === typeof input.title || __$assertGuard.$assertGuard(_exceptionable, {
332
+ }, _errorFactory)); const $ao3 = (input, _path, _exceptionable = true) => (undefined === input.title || "string" === typeof input.title || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
333
333
  method: "typia.assert",
334
334
  path: _path + ".title",
335
335
  expected: "(string | undefined)",
336
336
  value: input.title
337
- }, _errorFactory)) && (undefined === input.summary || "string" === typeof input.summary || __$assertGuard.$assertGuard(_exceptionable, {
337
+ }, _errorFactory)) && (undefined === input.summary || "string" === typeof input.summary || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
338
338
  method: "typia.assert",
339
339
  path: _path + ".summary",
340
340
  expected: "(string | undefined)",
341
341
  value: input.summary
342
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
342
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
343
343
  method: "typia.assert",
344
344
  path: _path + ".description",
345
345
  expected: "(string | undefined)",
346
346
  value: input.description
347
- }, _errorFactory)) && (undefined === input.termsOfService || "string" === typeof input.termsOfService || __$assertGuard.$assertGuard(_exceptionable, {
347
+ }, _errorFactory)) && (undefined === input.termsOfService || "string" === typeof input.termsOfService || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
348
348
  method: "typia.assert",
349
349
  path: _path + ".termsOfService",
350
350
  expected: "(string | undefined)",
351
351
  value: input.termsOfService
352
- }, _errorFactory)) && (undefined === input.contact || ("object" === typeof input.contact && null !== input.contact && false === Array.isArray(input.contact) || __$assertGuard.$assertGuard(_exceptionable, {
352
+ }, _errorFactory)) && (undefined === input.contact || ("object" === typeof input.contact && null !== input.contact && false === Array.isArray(input.contact) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
353
353
  method: "typia.assert",
354
354
  path: _path + ".contact",
355
355
  expected: "(OpenApi.IDocument.IContact | undefined)",
356
356
  value: input.contact
357
- }, _errorFactory)) && $ao4(input.contact, _path + ".contact", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
357
+ }, _errorFactory)) && $ao4(input.contact, _path + ".contact", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
358
358
  method: "typia.assert",
359
359
  path: _path + ".contact",
360
360
  expected: "(OpenApi.IDocument.IContact | undefined)",
361
361
  value: input.contact
362
- }, _errorFactory)) && (undefined === input.license || ("object" === typeof input.license && null !== input.license || __$assertGuard.$assertGuard(_exceptionable, {
362
+ }, _errorFactory)) && (undefined === input.license || ("object" === typeof input.license && null !== input.license || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
363
363
  method: "typia.assert",
364
364
  path: _path + ".license",
365
365
  expected: "(OpenApi.IDocument.ILicense | undefined)",
366
366
  value: input.license
367
- }, _errorFactory)) && $ao5(input.license, _path + ".license", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
367
+ }, _errorFactory)) && $ao5(input.license, _path + ".license", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
368
368
  method: "typia.assert",
369
369
  path: _path + ".license",
370
370
  expected: "(OpenApi.IDocument.ILicense | undefined)",
371
371
  value: input.license
372
- }, _errorFactory)) && (undefined === input.version || "string" === typeof input.version || __$assertGuard.$assertGuard(_exceptionable, {
372
+ }, _errorFactory)) && (undefined === input.version || "string" === typeof input.version || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
373
373
  method: "typia.assert",
374
374
  path: _path + ".version",
375
375
  expected: "(string | undefined)",
376
376
  value: input.version
377
- }, _errorFactory)); const $ao4 = (input, _path, _exceptionable = true) => (undefined === input.name || "string" === typeof input.name || __$assertGuard.$assertGuard(_exceptionable, {
377
+ }, _errorFactory)); const $ao4 = (input, _path, _exceptionable = true) => (undefined === input.name || "string" === typeof input.name || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
378
378
  method: "typia.assert",
379
379
  path: _path + ".name",
380
380
  expected: "(string | undefined)",
381
381
  value: input.name
382
- }, _errorFactory)) && (undefined === input.url || "string" === typeof input.url || __$assertGuard.$assertGuard(_exceptionable, {
382
+ }, _errorFactory)) && (undefined === input.url || "string" === typeof input.url || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
383
383
  method: "typia.assert",
384
384
  path: _path + ".url",
385
385
  expected: "(string | undefined)",
386
386
  value: input.url
387
- }, _errorFactory)) && (undefined === input.email || "string" === typeof input.email && (/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(input.email) || __$assertGuard.$assertGuard(_exceptionable, {
387
+ }, _errorFactory)) && (undefined === input.email || "string" === typeof input.email && (/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(input.email) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
388
388
  method: "typia.assert",
389
389
  path: _path + ".email",
390
390
  expected: "string & Format<\"email\">",
391
391
  value: input.email
392
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
392
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
393
393
  method: "typia.assert",
394
394
  path: _path + ".email",
395
395
  expected: "((string & Format<\"email\">) | undefined)",
396
396
  value: input.email
397
- }, _errorFactory)); const $ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || __$assertGuard.$assertGuard(_exceptionable, {
397
+ }, _errorFactory)); const $ao5 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
398
398
  method: "typia.assert",
399
399
  path: _path + ".name",
400
400
  expected: "string",
401
401
  value: input.name
402
- }, _errorFactory)) && (undefined === input.identifier || "string" === typeof input.identifier || __$assertGuard.$assertGuard(_exceptionable, {
402
+ }, _errorFactory)) && (undefined === input.identifier || "string" === typeof input.identifier || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
403
403
  method: "typia.assert",
404
404
  path: _path + ".identifier",
405
405
  expected: "(string | undefined)",
406
406
  value: input.identifier
407
- }, _errorFactory)) && (undefined === input.url || "string" === typeof input.url || __$assertGuard.$assertGuard(_exceptionable, {
407
+ }, _errorFactory)) && (undefined === input.url || "string" === typeof input.url || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
408
408
  method: "typia.assert",
409
409
  path: _path + ".url",
410
410
  expected: "(string | undefined)",
411
411
  value: input.url
412
- }, _errorFactory)); const $ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.url || __$assertGuard.$assertGuard(_exceptionable, {
412
+ }, _errorFactory)); const $ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.url || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
413
413
  method: "typia.assert",
414
414
  path: _path + ".url",
415
415
  expected: "string",
416
416
  value: input.url
417
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
417
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
418
418
  method: "typia.assert",
419
419
  path: _path + ".description",
420
420
  expected: "(string | undefined)",
421
421
  value: input.description
422
- }, _errorFactory)) && (undefined === input.variables || ("object" === typeof input.variables && null !== input.variables && false === Array.isArray(input.variables) || __$assertGuard.$assertGuard(_exceptionable, {
422
+ }, _errorFactory)) && (undefined === input.variables || ("object" === typeof input.variables && null !== input.variables && false === Array.isArray(input.variables) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
423
423
  method: "typia.assert",
424
424
  path: _path + ".variables",
425
425
  expected: "(Record<string, OpenApi.IServer.IVariable> | undefined)",
426
426
  value: input.variables
427
- }, _errorFactory)) && $ao7(input.variables, _path + ".variables", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
427
+ }, _errorFactory)) && $ao7(input.variables, _path + ".variables", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
428
428
  method: "typia.assert",
429
429
  path: _path + ".variables",
430
430
  expected: "(Record<string, OpenApi.IServer.IVariable> | undefined)",
@@ -433,38 +433,38 @@ var NestiaConfigLoader;
433
433
  const value = input[key];
434
434
  if (undefined === value)
435
435
  return true;
436
- return ("object" === typeof value && null !== value || __$assertGuard.$assertGuard(_exceptionable, {
436
+ return ("object" === typeof value && null !== value || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
437
437
  method: "typia.assert",
438
- path: _path + __$accessExpressionAsString.$accessExpressionAsString(key),
438
+ path: _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key),
439
439
  expected: "OpenApi.IServer.IVariable",
440
440
  value: value
441
- }, _errorFactory)) && $ao8(value, _path + __$accessExpressionAsString.$accessExpressionAsString(key), true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
441
+ }, _errorFactory)) && $ao8(value, _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key), true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
442
442
  method: "typia.assert",
443
- path: _path + __$accessExpressionAsString.$accessExpressionAsString(key),
443
+ path: _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key),
444
444
  expected: "OpenApi.IServer.IVariable",
445
445
  value: value
446
446
  }, _errorFactory);
447
- }); const $ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input["default"] || __$assertGuard.$assertGuard(_exceptionable, {
447
+ }); const $ao8 = (input, _path, _exceptionable = true) => ("string" === typeof input["default"] || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
448
448
  method: "typia.assert",
449
449
  path: _path + "[\"default\"]",
450
450
  expected: "string",
451
451
  value: input["default"]
452
- }, _errorFactory)) && (undefined === input["enum"] || (Array.isArray(input["enum"]) || __$assertGuard.$assertGuard(_exceptionable, {
452
+ }, _errorFactory)) && (undefined === input["enum"] || (Array.isArray(input["enum"]) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
453
453
  method: "typia.assert",
454
454
  path: _path + "[\"enum\"]",
455
455
  expected: "(Array<string> | undefined)",
456
456
  value: input["enum"]
457
- }, _errorFactory)) && input["enum"].every((elem, _index14) => "string" === typeof elem || __$assertGuard.$assertGuard(_exceptionable, {
457
+ }, _errorFactory)) && input["enum"].every((elem, _index14) => "string" === typeof elem || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
458
458
  method: "typia.assert",
459
459
  path: _path + "[\"enum\"][" + _index14 + "]",
460
460
  expected: "string",
461
461
  value: elem
462
- }, _errorFactory)) || __$assertGuard.$assertGuard(_exceptionable, {
462
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
463
463
  method: "typia.assert",
464
464
  path: _path + "[\"enum\"]",
465
465
  expected: "(Array<string> | undefined)",
466
466
  value: input["enum"]
467
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
467
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
468
468
  method: "typia.assert",
469
469
  path: _path + ".description",
470
470
  expected: "(string | undefined)",
@@ -473,153 +473,153 @@ var NestiaConfigLoader;
473
473
  const value = input[key];
474
474
  if (undefined === value)
475
475
  return true;
476
- return ("object" === typeof value && null !== value || __$assertGuard.$assertGuard(_exceptionable, {
476
+ return ("object" === typeof value && null !== value || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
477
477
  method: "typia.assert",
478
- path: _path + __$accessExpressionAsString.$accessExpressionAsString(key),
478
+ path: _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key),
479
479
  expected: "(OpenApi.ISecurityScheme.IApiKey | OpenApi.ISecurityScheme.IHttpBasic | OpenApi.ISecurityScheme.IHttpBearer | OpenApi.ISecurityScheme.IOAuth2 | OpenApi.ISecurityScheme.IOpenId)",
480
480
  value: value
481
- }, _errorFactory)) && $au0(value, _path + __$accessExpressionAsString.$accessExpressionAsString(key), true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
481
+ }, _errorFactory)) && $au0(value, _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key), true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
482
482
  method: "typia.assert",
483
- path: _path + __$accessExpressionAsString.$accessExpressionAsString(key),
483
+ path: _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key),
484
484
  expected: "(OpenApi.ISecurityScheme.IApiKey | OpenApi.ISecurityScheme.IHttpBasic | OpenApi.ISecurityScheme.IHttpBearer | OpenApi.ISecurityScheme.IOAuth2 | OpenApi.ISecurityScheme.IOpenId)",
485
485
  value: value
486
486
  }, _errorFactory);
487
- }); const $ao10 = (input, _path, _exceptionable = true) => ("apiKey" === input.type || __$assertGuard.$assertGuard(_exceptionable, {
487
+ }); const $ao10 = (input, _path, _exceptionable = true) => ("apiKey" === input.type || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
488
488
  method: "typia.assert",
489
489
  path: _path + ".type",
490
490
  expected: "\"apiKey\"",
491
491
  value: input.type
492
- }, _errorFactory)) && (undefined === input["in"] || "query" === input["in"] || "header" === input["in"] || "cookie" === input["in"] || __$assertGuard.$assertGuard(_exceptionable, {
492
+ }, _errorFactory)) && (undefined === input["in"] || "query" === input["in"] || "header" === input["in"] || "cookie" === input["in"] || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
493
493
  method: "typia.assert",
494
494
  path: _path + "[\"in\"]",
495
495
  expected: "(\"cookie\" | \"header\" | \"query\" | undefined)",
496
496
  value: input["in"]
497
- }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __$assertGuard.$assertGuard(_exceptionable, {
497
+ }, _errorFactory)) && (undefined === input.name || "string" === typeof input.name || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
498
498
  method: "typia.assert",
499
499
  path: _path + ".name",
500
500
  expected: "(string | undefined)",
501
501
  value: input.name
502
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
502
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
503
503
  method: "typia.assert",
504
504
  path: _path + ".description",
505
505
  expected: "(string | undefined)",
506
506
  value: input.description
507
- }, _errorFactory)); const $ao11 = (input, _path, _exceptionable = true) => ("http" === input.type || __$assertGuard.$assertGuard(_exceptionable, {
507
+ }, _errorFactory)); const $ao11 = (input, _path, _exceptionable = true) => ("http" === input.type || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
508
508
  method: "typia.assert",
509
509
  path: _path + ".type",
510
510
  expected: "\"http\"",
511
511
  value: input.type
512
- }, _errorFactory)) && ("basic" === input.scheme || __$assertGuard.$assertGuard(_exceptionable, {
512
+ }, _errorFactory)) && ("basic" === input.scheme || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
513
513
  method: "typia.assert",
514
514
  path: _path + ".scheme",
515
515
  expected: "\"basic\"",
516
516
  value: input.scheme
517
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
517
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
518
518
  method: "typia.assert",
519
519
  path: _path + ".description",
520
520
  expected: "(string | undefined)",
521
521
  value: input.description
522
- }, _errorFactory)); const $ao12 = (input, _path, _exceptionable = true) => ("http" === input.type || __$assertGuard.$assertGuard(_exceptionable, {
522
+ }, _errorFactory)); const $ao12 = (input, _path, _exceptionable = true) => ("http" === input.type || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
523
523
  method: "typia.assert",
524
524
  path: _path + ".type",
525
525
  expected: "\"http\"",
526
526
  value: input.type
527
- }, _errorFactory)) && ("bearer" === input.scheme || __$assertGuard.$assertGuard(_exceptionable, {
527
+ }, _errorFactory)) && ("bearer" === input.scheme || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
528
528
  method: "typia.assert",
529
529
  path: _path + ".scheme",
530
530
  expected: "\"bearer\"",
531
531
  value: input.scheme
532
- }, _errorFactory)) && (undefined === input.bearerFormat || "string" === typeof input.bearerFormat || __$assertGuard.$assertGuard(_exceptionable, {
532
+ }, _errorFactory)) && (undefined === input.bearerFormat || "string" === typeof input.bearerFormat || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
533
533
  method: "typia.assert",
534
534
  path: _path + ".bearerFormat",
535
535
  expected: "(string | undefined)",
536
536
  value: input.bearerFormat
537
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
537
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
538
538
  method: "typia.assert",
539
539
  path: _path + ".description",
540
540
  expected: "(string | undefined)",
541
541
  value: input.description
542
- }, _errorFactory)); const $ao13 = (input, _path, _exceptionable = true) => ("oauth2" === input.type || __$assertGuard.$assertGuard(_exceptionable, {
542
+ }, _errorFactory)); const $ao13 = (input, _path, _exceptionable = true) => ("oauth2" === input.type || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
543
543
  method: "typia.assert",
544
544
  path: _path + ".type",
545
545
  expected: "\"oauth2\"",
546
546
  value: input.type
547
- }, _errorFactory)) && (("object" === typeof input.flows && null !== input.flows && false === Array.isArray(input.flows) || __$assertGuard.$assertGuard(_exceptionable, {
547
+ }, _errorFactory)) && (("object" === typeof input.flows && null !== input.flows && false === Array.isArray(input.flows) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
548
548
  method: "typia.assert",
549
549
  path: _path + ".flows",
550
550
  expected: "OpenApi.ISecurityScheme.IOAuth2.IFlowSet",
551
551
  value: input.flows
552
- }, _errorFactory)) && $ao14(input.flows, _path + ".flows", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
552
+ }, _errorFactory)) && $ao14(input.flows, _path + ".flows", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
553
553
  method: "typia.assert",
554
554
  path: _path + ".flows",
555
555
  expected: "OpenApi.ISecurityScheme.IOAuth2.IFlowSet",
556
556
  value: input.flows
557
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
557
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
558
558
  method: "typia.assert",
559
559
  path: _path + ".description",
560
560
  expected: "(string | undefined)",
561
561
  value: input.description
562
- }, _errorFactory)); const $ao14 = (input, _path, _exceptionable = true) => (undefined === input.authorizationCode || ("object" === typeof input.authorizationCode && null !== input.authorizationCode && false === Array.isArray(input.authorizationCode) || __$assertGuard.$assertGuard(_exceptionable, {
562
+ }, _errorFactory)); const $ao14 = (input, _path, _exceptionable = true) => (undefined === input.authorizationCode || ("object" === typeof input.authorizationCode && null !== input.authorizationCode && false === Array.isArray(input.authorizationCode) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
563
563
  method: "typia.assert",
564
564
  path: _path + ".authorizationCode",
565
565
  expected: "(OpenApi.ISecurityScheme.IOAuth2.IFlow | undefined)",
566
566
  value: input.authorizationCode
567
- }, _errorFactory)) && $ao15(input.authorizationCode, _path + ".authorizationCode", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
567
+ }, _errorFactory)) && $ao15(input.authorizationCode, _path + ".authorizationCode", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
568
568
  method: "typia.assert",
569
569
  path: _path + ".authorizationCode",
570
570
  expected: "(OpenApi.ISecurityScheme.IOAuth2.IFlow | undefined)",
571
571
  value: input.authorizationCode
572
- }, _errorFactory)) && (undefined === input.implicit || ("object" === typeof input.implicit && null !== input.implicit && false === Array.isArray(input.implicit) || __$assertGuard.$assertGuard(_exceptionable, {
572
+ }, _errorFactory)) && (undefined === input.implicit || ("object" === typeof input.implicit && null !== input.implicit && false === Array.isArray(input.implicit) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
573
573
  method: "typia.assert",
574
574
  path: _path + ".implicit",
575
575
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"tokenUrl\"> | undefined)",
576
576
  value: input.implicit
577
- }, _errorFactory)) && $ao17(input.implicit, _path + ".implicit", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
577
+ }, _errorFactory)) && $ao17(input.implicit, _path + ".implicit", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
578
578
  method: "typia.assert",
579
579
  path: _path + ".implicit",
580
580
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"tokenUrl\"> | undefined)",
581
581
  value: input.implicit
582
- }, _errorFactory)) && (undefined === input.password || ("object" === typeof input.password && null !== input.password && false === Array.isArray(input.password) || __$assertGuard.$assertGuard(_exceptionable, {
582
+ }, _errorFactory)) && (undefined === input.password || ("object" === typeof input.password && null !== input.password && false === Array.isArray(input.password) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
583
583
  method: "typia.assert",
584
584
  path: _path + ".password",
585
585
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
586
586
  value: input.password
587
- }, _errorFactory)) && $ao18(input.password, _path + ".password", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
587
+ }, _errorFactory)) && $ao18(input.password, _path + ".password", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
588
588
  method: "typia.assert",
589
589
  path: _path + ".password",
590
590
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
591
591
  value: input.password
592
- }, _errorFactory)) && (undefined === input.clientCredentials || ("object" === typeof input.clientCredentials && null !== input.clientCredentials && false === Array.isArray(input.clientCredentials) || __$assertGuard.$assertGuard(_exceptionable, {
592
+ }, _errorFactory)) && (undefined === input.clientCredentials || ("object" === typeof input.clientCredentials && null !== input.clientCredentials && false === Array.isArray(input.clientCredentials) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
593
593
  method: "typia.assert",
594
594
  path: _path + ".clientCredentials",
595
595
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
596
596
  value: input.clientCredentials
597
- }, _errorFactory)) && $ao18(input.clientCredentials, _path + ".clientCredentials", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
597
+ }, _errorFactory)) && $ao18(input.clientCredentials, _path + ".clientCredentials", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
598
598
  method: "typia.assert",
599
599
  path: _path + ".clientCredentials",
600
600
  expected: "(Omit<OpenApi.ISecurityScheme.IOAuth2.IFlow, \"authorizationUrl\"> | undefined)",
601
601
  value: input.clientCredentials
602
- }, _errorFactory)); const $ao15 = (input, _path, _exceptionable = true) => (undefined === input.authorizationUrl || "string" === typeof input.authorizationUrl || __$assertGuard.$assertGuard(_exceptionable, {
602
+ }, _errorFactory)); const $ao15 = (input, _path, _exceptionable = true) => (undefined === input.authorizationUrl || "string" === typeof input.authorizationUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
603
603
  method: "typia.assert",
604
604
  path: _path + ".authorizationUrl",
605
605
  expected: "(string | undefined)",
606
606
  value: input.authorizationUrl
607
- }, _errorFactory)) && (undefined === input.tokenUrl || "string" === typeof input.tokenUrl || __$assertGuard.$assertGuard(_exceptionable, {
607
+ }, _errorFactory)) && (undefined === input.tokenUrl || "string" === typeof input.tokenUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
608
608
  method: "typia.assert",
609
609
  path: _path + ".tokenUrl",
610
610
  expected: "(string | undefined)",
611
611
  value: input.tokenUrl
612
- }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __$assertGuard.$assertGuard(_exceptionable, {
612
+ }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
613
613
  method: "typia.assert",
614
614
  path: _path + ".refreshUrl",
615
615
  expected: "(string | undefined)",
616
616
  value: input.refreshUrl
617
- }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __$assertGuard.$assertGuard(_exceptionable, {
617
+ }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
618
618
  method: "typia.assert",
619
619
  path: _path + ".scopes",
620
620
  expected: "(Record<string, string> | undefined)",
621
621
  value: input.scopes
622
- }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
622
+ }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
623
623
  method: "typia.assert",
624
624
  path: _path + ".scopes",
625
625
  expected: "(Record<string, string> | undefined)",
@@ -628,73 +628,73 @@ var NestiaConfigLoader;
628
628
  const value = input[key];
629
629
  if (undefined === value)
630
630
  return true;
631
- return "string" === typeof value || __$assertGuard.$assertGuard(_exceptionable, {
631
+ return "string" === typeof value || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
632
632
  method: "typia.assert",
633
- path: _path + __$accessExpressionAsString.$accessExpressionAsString(key),
633
+ path: _path + __typia_transform_$accessExpressionAsString.$accessExpressionAsString(key),
634
634
  expected: "string",
635
635
  value: value
636
636
  }, _errorFactory);
637
- }); const $ao17 = (input, _path, _exceptionable = true) => (undefined === input.authorizationUrl || "string" === typeof input.authorizationUrl || __$assertGuard.$assertGuard(_exceptionable, {
637
+ }); const $ao17 = (input, _path, _exceptionable = true) => (undefined === input.authorizationUrl || "string" === typeof input.authorizationUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
638
638
  method: "typia.assert",
639
639
  path: _path + ".authorizationUrl",
640
640
  expected: "(string | undefined)",
641
641
  value: input.authorizationUrl
642
- }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __$assertGuard.$assertGuard(_exceptionable, {
642
+ }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
643
643
  method: "typia.assert",
644
644
  path: _path + ".refreshUrl",
645
645
  expected: "(string | undefined)",
646
646
  value: input.refreshUrl
647
- }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __$assertGuard.$assertGuard(_exceptionable, {
647
+ }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
648
648
  method: "typia.assert",
649
649
  path: _path + ".scopes",
650
650
  expected: "(Record<string, string> | undefined)",
651
651
  value: input.scopes
652
- }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
652
+ }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
653
653
  method: "typia.assert",
654
654
  path: _path + ".scopes",
655
655
  expected: "(Record<string, string> | undefined)",
656
656
  value: input.scopes
657
- }, _errorFactory)); const $ao18 = (input, _path, _exceptionable = true) => (undefined === input.tokenUrl || "string" === typeof input.tokenUrl || __$assertGuard.$assertGuard(_exceptionable, {
657
+ }, _errorFactory)); const $ao18 = (input, _path, _exceptionable = true) => (undefined === input.tokenUrl || "string" === typeof input.tokenUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
658
658
  method: "typia.assert",
659
659
  path: _path + ".tokenUrl",
660
660
  expected: "(string | undefined)",
661
661
  value: input.tokenUrl
662
- }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __$assertGuard.$assertGuard(_exceptionable, {
662
+ }, _errorFactory)) && (undefined === input.refreshUrl || "string" === typeof input.refreshUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
663
663
  method: "typia.assert",
664
664
  path: _path + ".refreshUrl",
665
665
  expected: "(string | undefined)",
666
666
  value: input.refreshUrl
667
- }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __$assertGuard.$assertGuard(_exceptionable, {
667
+ }, _errorFactory)) && (undefined === input.scopes || ("object" === typeof input.scopes && null !== input.scopes && false === Array.isArray(input.scopes) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
668
668
  method: "typia.assert",
669
669
  path: _path + ".scopes",
670
670
  expected: "(Record<string, string> | undefined)",
671
671
  value: input.scopes
672
- }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __$assertGuard.$assertGuard(_exceptionable, {
672
+ }, _errorFactory)) && $ao16(input.scopes, _path + ".scopes", true && _exceptionable) || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
673
673
  method: "typia.assert",
674
674
  path: _path + ".scopes",
675
675
  expected: "(Record<string, string> | undefined)",
676
676
  value: input.scopes
677
- }, _errorFactory)); const $ao19 = (input, _path, _exceptionable = true) => ("openIdConnect" === input.type || __$assertGuard.$assertGuard(_exceptionable, {
677
+ }, _errorFactory)); const $ao19 = (input, _path, _exceptionable = true) => ("openIdConnect" === input.type || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
678
678
  method: "typia.assert",
679
679
  path: _path + ".type",
680
680
  expected: "\"openIdConnect\"",
681
681
  value: input.type
682
- }, _errorFactory)) && ("string" === typeof input.openIdConnectUrl || __$assertGuard.$assertGuard(_exceptionable, {
682
+ }, _errorFactory)) && ("string" === typeof input.openIdConnectUrl || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
683
683
  method: "typia.assert",
684
684
  path: _path + ".openIdConnectUrl",
685
685
  expected: "string",
686
686
  value: input.openIdConnectUrl
687
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
687
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
688
688
  method: "typia.assert",
689
689
  path: _path + ".description",
690
690
  expected: "(string | undefined)",
691
691
  value: input.description
692
- }, _errorFactory)); const $ao20 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || __$assertGuard.$assertGuard(_exceptionable, {
692
+ }, _errorFactory)); const $ao20 = (input, _path, _exceptionable = true) => ("string" === typeof input.name || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
693
693
  method: "typia.assert",
694
694
  path: _path + ".name",
695
695
  expected: "string",
696
696
  value: input.name
697
- }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __$assertGuard.$assertGuard(_exceptionable, {
697
+ }, _errorFactory)) && (undefined === input.description || "string" === typeof input.description || __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
698
698
  method: "typia.assert",
699
699
  path: _path + ".description",
700
700
  expected: "(string | undefined)",
@@ -711,7 +711,7 @@ var NestiaConfigLoader;
711
711
  else if ("openIdConnect" === input.type)
712
712
  return $ao19(input, _path, true && _exceptionable);
713
713
  else
714
- return __$assertGuard.$assertGuard(_exceptionable, {
714
+ return __typia_transform_$assertGuard.$assertGuard(_exceptionable, {
715
715
  method: "typia.assert",
716
716
  path: _path,
717
717
  expected: "(OpenApi.ISecurityScheme.IApiKey | OpenApi.ISecurityScheme.IHttpBasic | OpenApi.ISecurityScheme.IHttpBearer | OpenApi.ISecurityScheme.IOAuth2 | OpenApi.ISecurityScheme.IOpenId)",
@@ -720,22 +720,22 @@ var NestiaConfigLoader;
720
720
  })(); const __is = input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && $io0(elem)); let _errorFactory; return (input, errorFactory) => {
721
721
  if (false === __is(input)) {
722
722
  _errorFactory = errorFactory;
723
- ((input, _path, _exceptionable = true) => (Array.isArray(input) || __$assertGuard.$assertGuard(true, {
723
+ ((input, _path, _exceptionable = true) => (Array.isArray(input) || __typia_transform_$assertGuard.$assertGuard(true, {
724
724
  method: "typia.assert",
725
725
  path: _path + "",
726
726
  expected: "Array<INestiaConfig>",
727
727
  value: input
728
- }, _errorFactory)) && input.every((elem, _index8) => ("object" === typeof elem && null !== elem || __$assertGuard.$assertGuard(true, {
728
+ }, _errorFactory)) && input.every((elem, _index8) => ("object" === typeof elem && null !== elem || __typia_transform_$assertGuard.$assertGuard(true, {
729
729
  method: "typia.assert",
730
730
  path: _path + "[" + _index8 + "]",
731
731
  expected: "INestiaConfig",
732
732
  value: elem
733
- }, _errorFactory)) && $ao0(elem, _path + "[" + _index8 + "]", true) || __$assertGuard.$assertGuard(true, {
733
+ }, _errorFactory)) && $ao0(elem, _path + "[" + _index8 + "]", true) || __typia_transform_$assertGuard.$assertGuard(true, {
734
734
  method: "typia.assert",
735
735
  path: _path + "[" + _index8 + "]",
736
736
  expected: "INestiaConfig",
737
737
  value: elem
738
- }, _errorFactory)) || __$assertGuard.$assertGuard(true, {
738
+ }, _errorFactory)) || __typia_transform_$assertGuard.$assertGuard(true, {
739
739
  method: "typia.assert",
740
740
  path: _path + "",
741
741
  expected: "Array<INestiaConfig>",