SignpostMarv/JSON-Schema-TypeScript-CodeGen | Build 19133596245 | src/JSONSchema/Object.ts | Coveralls

1

import type {

19✔

2

        IndexSignatureDeclaration,

19✔

3

        ObjectLiteralExpression,

19✔

4

        PropertySignature,

19✔

5

        TypeNode,

19✔

6

} from 'typescript';

19✔

7

import {

19✔

8

        SyntaxKind,

19✔

9

} from 'typescript';

19✔

10

19✔

11

import type {

19✔

12

        SchemaDefinitionDefinition,

19✔

13

        SchemaDefinitionDefinitionWith$defs,

19✔

14

        TypeDefinitionSchema,

19✔

15

        TypeOptions,

19✔

16

} from './Type.ts';

19✔

17

import {

19✔

18

        $defs_schema,

19✔

19

        Type,

19✔

20

} from './Type.ts';

19✔

21

19✔

22

import type {

19✔

23

        ExternalRef,

19✔

24

        LocalRef,

19✔

25

        pattern_either,

19✔

26

} from './Ref.ts';

19✔

27

19✔

28

import {

19✔

29

        $ref,

19✔

30

} from './Ref.ts';

19✔

31

19✔

32

import type {

19✔

33

        unknown_type,

19✔

34

} from './Unknown.ts';

19✔

35

19✔

36

import type {

19✔

37

        ObjectOfSchemas,

19✔

38

        SchemaObject,

19✔

39

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

40

} from '../types.ts';

19✔

41

19✔

42

import type {

19✔

43

        IntersectionTypeNode,

19✔

44

        TypeLiteralNode,

19✔

45

        TypeReferenceNode,

19✔

46

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

47

} from '../typescript/types.ts';

19✔

48

19✔

49

import type {

19✔

50

        adjust_name_callback,

19✔

51

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

52

} from '../coercions.ts';

19✔

53

import {

19✔

54

        adjust_name_default,

19✔

55

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

56

} from '../coercions.ts';

19✔

57

19✔

58

import {

19✔

59

        factory,

19✔

60

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

61

} from '../typescript/factory.ts';

19✔

62

19✔

63

import type {

19✔

64

        SchemaParser,

19✔

65

// eslint-disable-next-line imports/no-relative-parent-imports

19✔

66

} from '../SchemaParser.ts';

19✔

67

19✔

68

type object_properties_mode = (

19✔

69

        | 'neither'

19✔

70

        | 'both'

19✔

71

        | 'properties'

19✔

72

        | 'pattern'

19✔

73

);

19✔

74

19✔

75

type object_type_base<

19✔

76

        PropertiesMode extends object_properties_mode,

19✔

77

        Defs extends SchemaObject,

19✔

78

        Required extends readonly [string, ...string[]],

19✔

79

        Properties extends ObjectOfSchemas,

19✔

80

        PatternProperties extends ObjectOfSchemas,

19✔

81

> = (

19✔

82

& {

19✔

83

                $defs?: Defs,

19✔

84

                $ref?: LocalRef|ExternalRef,

19✔

85

                type: 'object',

19✔

86

                required?: Required,

19✔

87

                additionalProperties?: boolean,

19✔

88

                unevaluatedProperties?: boolean,

19✔

89

19✔

90

        & Omit<

19✔

91

19✔

92

                        properties: Properties,

19✔

93

                        patternProperties: PatternProperties,

19✔

94

},

19✔

95

19✔

96

                        both: '',

19✔

97

                        neither: 'properties'|'patternProperties',

19✔

98

                        properties: 'patternProperties',

19✔

99

                        pattern: 'properties',

19✔

100

                }[PropertiesMode]

19✔

101

19✔

102

);

19✔

103

19✔

104

type object_type<

19✔

105

        PropertiesMode extends object_properties_mode,

19✔

106

        Defs extends SchemaObject,

19✔

107

        Required extends readonly [string, ...string[]],

19✔

108

        Properties extends ObjectOfSchemas,

19✔

109

        PatternProperties extends ObjectOfSchemas,

19✔

110

> = (

19✔

111

        | object_type_base<

19✔

112

                PropertiesMode,

19✔

113

                Defs,

19✔

114

                Required,

19✔

115

                Properties,

19✔

116

                PatternProperties

19✔

117

19✔

118

| {

19✔

119

                type: 'object',

19✔

120

                $defs: Defs,

19✔

121

                $ref: LocalRef|ExternalRef,

19✔

122

19✔

123

);

19✔

124

19✔

125

type object_schema_required<

19✔

126

        PropertiesMode extends object_properties_mode,

19✔

127

> = (

19✔

128

        & readonly [string, ...string[]]

19✔

129

& [

19✔

130

                'type',

19✔

131

                ...{

19✔

132

                        neither: readonly string[],

19✔

133

                        both: readonly ['properties', 'patternProperties'],

19✔

134

                        properties: readonly ['properties'],

19✔

135

                        pattern: readonly ['patternProperties'],

19✔

136

                }[PropertiesMode],

19✔

137

19✔

138

);

19✔

139

19✔

140

type object_schema_properties_base = {

19✔

141

        type: {

19✔

142

                type: 'string',

19✔

143

                const: 'object',

19✔

144

},

19✔

145

        required: {

19✔

146

                type: 'array',

19✔

147

                minItems: 1,

19✔

148

                items: {

19✔

149

                        type: 'string',

19✔

150

                        minLength: 1,

19✔

151

},

19✔

152

},

19✔

153

        $ref: {

19✔

154

                type: 'string',

19✔

155

                pattern: pattern_either,

19✔

156

},

19✔

157

        additionalProperties: {

19✔

158

                type: 'boolean',

19✔

159

},

19✔

160

        unevaluatedProperties: {

19✔

161

                type: 'boolean',

19✔

162

},

19✔

163

};

19✔

164

19✔

165

type object_schema_properties_properties = {

19✔

166

        properties: {

19✔

167

                type: 'object',

19✔

168

                minProperties: 1,

19✔

169

                additionalProperties: {

19✔

170

                        type: 'object',

19✔

171

},

19✔

172

},

19✔

173

};

19✔

174

19✔

175

type object_schema_properties_pattern = {

19✔

176

        patternProperties: {

19✔

177

                type: 'object',

19✔

178

                minProperties: 1,

19✔

179

                additionalProperties: {

19✔

180

                        type: 'object',

19✔

181

},

19✔

182

},

19✔

183

};

19✔

184

19✔

185

type object_properties_by_mode<

19✔

186

        PropertiesMode extends object_properties_mode,

19✔

187

> = {

19✔

188

        both: (

19✔

189

                & object_schema_properties_properties

19✔

190

                & object_schema_properties_pattern

19✔

191

),

19✔

192

        properties: object_schema_properties_properties,

19✔

193

        pattern: object_schema_properties_pattern,

19✔

194

        neither: {

19✔

195

                additionalProperties: {

19✔

196

                        type: 'boolean',

19✔

197

                        const: false,

19✔

198

},

19✔

199

                maxProperties: {

19✔

200

                        type: 'integer',

19✔

201

                        const: 0,

19✔

202

},

19✔

203

},

19✔

204

}[PropertiesMode];

19✔

205

19✔

206

type object_schema<

19✔

207

        PropertiesMode extends object_properties_mode,

19✔

208

> = SchemaDefinitionDefinitionWith$defs<

19✔

209

        object_schema_required<PropertiesMode>,

19✔

210

19✔

211

                & ObjectOfSchemas

19✔

212

                & object_schema_properties_base

19✔

213

                & object_properties_by_mode<PropertiesMode>

19✔

214

19✔

215

>;

19✔

216

19✔

217

type object_TypeLiteralNode<

19✔

218

        PropertiesMode extends object_properties_mode,

19✔

219

> = {

19✔

220

        ['neither']: TypeLiteralNode<

19✔

221

                IndexSignatureDeclaration

19✔

222

>,

19✔

223

        ['both']: IntersectionTypeNode<[

19✔

224

                TypeLiteralNode<PropertySignature>,

19✔

225

                TypeLiteralNode<IndexSignatureDeclaration>,

19✔

226

]>,

19✔

227

        ['properties']: TypeLiteralNode<PropertySignature>,

19✔

228

        ['pattern']: TypeLiteralNode<

19✔

229

                IndexSignatureDeclaration

19✔

230

>,

19✔

231

}[PropertiesMode];

19✔

232

19✔

233

type object_TypeLiteralNode_possibly_extended<

19✔

234

        PropertiesMode extends object_properties_mode,

19✔

235

> = (

19✔

236

        | object_TypeLiteralNode<PropertiesMode>

19✔

237

        | IntersectionTypeNode<[

19✔

238

                TypeReferenceNode,

19✔

239

                object_TypeLiteralNode<PropertiesMode>,

19✔

240

]>

19✔

241

);

19✔

242

19✔

243

type ObjectUncertain_options<

19✔

244

        SchemaDefinition extends (

19✔

245

                SchemaDefinitionDefinition

19✔

246

        ) = (

19✔

247

                SchemaDefinitionDefinition

19✔

248

),

19✔

249

        TypeDefinition extends TypeDefinitionSchema = TypeDefinitionSchema,

19✔

250

> = (

19✔

251

        & Omit<

19✔

252

                TypeOptions<SchemaDefinition, TypeDefinition>,

19✔

253

19✔

254

                        | 'schema_definition'

19✔

255

                        | 'type_definition'

19✔

256

19✔

257

19✔

258

);

19✔

259

19✔

260

class ObjectUnspecified<

19✔

261

        T extends {[key: string]: unknown},

19✔

262

        PropertiesMode extends object_properties_mode,

19✔

263

        Defs extends SchemaObject = SchemaObject,

19✔

264

        Required extends (

19✔

265

                readonly [string, ...string[]]

19✔

266

        ) = (

19✔

267

                readonly [string, ...string[]]

19✔

268

),

19✔

269

        Properties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

270

        PatternProperties extends ObjectOfSchemas = ObjectOfSchemas,

19✔

271

> extends

19✔

272

        Type<

19✔

273

T,

19✔

274

                object_type<

19✔

275

                        PropertiesMode,

19✔

276

                        Defs,

19✔

277

                        Required,

19✔

278

                        Properties,

19✔

279

                        PatternProperties

19✔

280

>,

19✔

281

19✔

282

                        properties_mode: PropertiesMode,

19✔

283

                        $defs?: Defs,

19✔

284

                        required?: Required,

19✔

285

                        properties?: Properties,

19✔

286

                        patternProperties?: PatternProperties,

19✔

287

},

19✔

288

                object_schema<

19✔

289

                        PropertiesMode

19✔

290

>,

19✔

291

19✔

292

                        properties_mode: PropertiesMode,

19✔

293

},

19✔

294

19✔

295

                        | object_TypeLiteralNode<PropertiesMode>

19✔

296

                        | IntersectionTypeNode<[

19✔

297

                                TypeReferenceNode,

19✔

298

                                object_TypeLiteralNode<PropertiesMode>,

19✔

299

]>

19✔

300

),

19✔

301

                ObjectLiteralExpression

19✔

302

> {

19✔

303

        #adjust_name: adjust_name_callback;

19✔

304

1,142✔

305

        readonly properties_mode: PropertiesMode;

19✔

306

19✔

307

        constructor(

19✔

308

                options: {

1,142✔

309

                        adjust_name?: adjust_name_callback,

1,142✔

310

                        properties_mode: PropertiesMode,

1,142✔

311

                        $defs?: Defs,

1,142✔

312

                        required?: Required,

1,142✔

313

                        properties?: Properties,

1,142✔

314

                        patternProperties?: PatternProperties,

1,142✔

315

},

1,142✔

316

1,142✔

317

                        ajv,

1,142✔

318

                }: ObjectUncertain_options<

1,142✔

319

                        object_schema<

1,142✔

320

                                PropertiesMode

1,142✔

321

>,

1,142✔

322

                        object_type<

1,142✔

323

                                PropertiesMode,

1,142✔

324

                                Defs,

1,142✔

325

                                Required,

1,142✔

326

                                Properties,

1,142✔

327

                                PatternProperties

1,142✔

328

1,142✔

329

>,

1,142✔

330

) {

1,142✔

331

                super({

1,142✔

332

                        ajv,

1,142✔

333

                        type_definition: options,

1,142✔

334

                        schema_definition: options,

1,142✔

335

});

1,142✔

336

1,142✔

337

                this.#adjust_name = options?.adjust_name || adjust_name_default;

1,142✔

338

                this.properties_mode = options.properties_mode;

1,142✔

339

1,142✔

340

19✔

341

        generate_typescript_data(

19✔

342

                data: T,

80✔

343

                schema_parser: SchemaParser,

80✔

344

                schema: object_type<

80✔

345

                        PropertiesMode,

80✔

346

                        Defs,

80✔

347

                        Required,

80✔

348

                        Properties,

80✔

349

                        PatternProperties

80✔

350

>,

80✔

351

        ): ObjectLiteralExpression {

80✔

352

                return ObjectUnspecified.#createObjectLiteralExpression(

80✔

353

                        this.properties_mode,

80✔

354

                        data,

80✔

355

                        schema,

80✔

356

                        schema_parser,

80✔

357

                        this.#adjust_name,

80✔

358

);

80✔

359

80✔

360

19✔

361

        async generate_typescript_type(

19✔

362

34✔

363

                        schema,

34✔

364

                        schema_parser,

34✔

365

                }: {

34✔

366

                        schema: object_type<

34✔

367

                                PropertiesMode,

34✔

368

                                Defs,

34✔

369

                                Required,

34✔

370

                                Properties,

34✔

371

                                PatternProperties

34✔

372

>,

34✔

373

                        schema_parser: SchemaParser,

34✔

374

},

34✔

375

        ): Promise<object_TypeLiteralNode_possibly_extended<PropertiesMode>> {

34✔

376

                let object_type: (

34✔

377

                        | Promise<object_TypeLiteralNode<PropertiesMode>>

34✔

378

                        | IntersectionTypeNode<[

34✔

379

                                TypeReferenceNode,

34✔

380

                                object_TypeLiteralNode<PropertiesMode>,

34✔

381

]>

34✔

382

                ) = ObjectUnspecified.#createTypeNode(

34✔

383

                        this.properties_mode,

34✔

384

                        schema,

34✔

385

                        schema_parser,

34✔

386

);

34✔

387

34✔

388

                if ('string' === typeof schema?.$ref) {

34✔

389

                        const $ref_instance = schema_parser.parse_by_type({

9✔

390

                                $ref: schema.$ref,

9✔

391

                        }, (maybe): maybe is $ref => $ref.is_a(maybe));

9✔

392

9✔

393

                        object_type = factory.createIntersectionTypeNode([

9✔

394

                                await $ref_instance.generate_typescript_type({

9✔

395

                                        schema: {

9✔

396

                                                $ref: schema.$ref,

9✔

397

},

9✔

398

}),

9✔

399

                                await object_type,

9✔

400

]);

9✔

401

9✔

402

34✔

403

                return object_type;

34✔

404

34✔

405

19✔

406

        static generate_schema_definition<

19✔

407

                PropertiesMode extends object_properties_mode,

1,146✔

408

>({

1,146✔

409

                properties_mode,

1,146✔

410

        }: {

1,146✔

411

                properties_mode: PropertiesMode,

1,146✔

412

        }): Readonly<object_schema<

1,146✔

413

                PropertiesMode

1,146✔

414

        >> {

1,146✔

415

                const required_for_partial = (

1,146✔

416

                        this.#generate_schema_definition_required(

1,146✔

417

                                properties_mode,

1,146✔

418

1,146✔

419

);

1,146✔

420

1,146✔

421

                const properties_for_partial: Partial<

1,146✔

422

                        object_schema<'both'>['properties']

1,146✔

423

                > = {

1,146✔

424

                        ...$defs_schema.properties,

1,146✔

425

                        type: {

1,146✔

426

                                type: 'string',

1,146✔

427

                                const: 'object',

1,146✔

428

},

1,146✔

429

                        $ref: {

1,146✔

430

                                type: 'string',

1,146✔

431

                                pattern: '^(.+)?#\\/\\$defs\\/(.+)$',

1,146✔

432

},

1,146✔

433

                        additionalProperties: {

1,146✔

434

                                type: 'boolean',

1,146✔

435

},

1,146✔

436

                        unevaluatedProperties: {

1,146✔

437

                                type: 'boolean',

1,146✔

438

},

1,146✔

439

};

1,146✔

440

1,146✔

441

                properties_for_partial.required = {

1,146✔

442

                        type: 'array',

1,146✔

443

                        minItems: 1,

1,146✔

444

                        items: {

1,146✔

445

                                type: 'string',

1,146✔

446

                                minLength: 1,

1,146✔

447

},

1,146✔

448

};

1,146✔

449

1,146✔

450

                if ('pattern' !== properties_mode && 'neither' !== properties_mode) {

1,146✔

451

                        const properties: (

582✔

452

                                object_schema<

582✔

453

                                        'properties'

582✔

454

                                >['properties']['properties']

582✔

455

                        ) = {

582✔

456

                                type: 'object',

582✔

457

                                minProperties: 1,

582✔

458

                                additionalProperties: {

582✔

459

                                        type: 'object',

582✔

460

},

582✔

461

};

582✔

462

                        properties_for_partial.properties = properties;

582✔

463

582✔

464

                if (

1,146✔

465

                        'properties' !== properties_mode

1,146✔

466

                        && 'neither' !== properties_mode

1,146✔

467

) {

1,146✔

468

                        const properties: (

562✔

469

                                object_schema<

562✔

470

                                        'pattern'

562✔

471

                                >['properties']['patternProperties']

562✔

472

                        ) = {

562✔

473

                                type: 'object',

562✔

474

                                minProperties: 1,

562✔

475

                                additionalProperties: {

562✔

476

                                        type: 'object',

562✔

477

},

562✔

478

};

562✔

479

                        properties_for_partial.patternProperties = properties;

562✔

480

562✔

481

1,146✔

482

                if ('neither' === properties_mode) {

1,146✔

483

283✔

484

                                properties_for_partial as Partial<

283✔

485

                                        object_schema<'neither'>['properties']

283✔

486

283✔

487

                        ).additionalProperties = {

283✔

488

                                type: 'boolean',

283✔

489

                                const: false,

283✔

490

};

283✔

491

283✔

492

                                properties_for_partial as Partial<

283✔

493

                                        object_schema<'neither'>['properties']

283✔

494

283✔

495

                        ).maxProperties = {

283✔

496

                                type: 'integer',

283✔

497

                                const: 0,

283✔

498

};

283✔

499

283✔

500

1,146✔

501

                const unpartial_properties: object_schema<

1,146✔

502

                        PropertiesMode

1,146✔

503

                >['properties'] = properties_for_partial as object_schema<

1,146✔

504

                        PropertiesMode

1,146✔

505

                >['properties'];

1,146✔

506

1,146✔

507

                const partial_required: object_schema<

1,146✔

508

                        PropertiesMode

1,146✔

509

                >['required'] = required_for_partial;

1,146✔

510

                const partial_properties: object_schema<

1,146✔

511

                        PropertiesMode

1,146✔

512

                >['properties'] = unpartial_properties;

1,146✔

513

1,146✔

514

                const result: object_schema<

1,146✔

515

                        PropertiesMode

1,146✔

516

                > = {

1,146✔

517

                        type: 'object',

1,146✔

518

                        required: partial_required,

1,146✔

519

                        additionalProperties: false,

1,146✔

520

                        properties: partial_properties,

1,146✔

521

                } as object_schema<

1,146✔

522

                        PropertiesMode

1,146✔

523

>;

1,146✔

524

1,146✔

525

                return Object.freeze(result);

1,146✔

526

1,146✔

527

19✔

528

        static #generate_schema_definition_required<

19✔

529

                PropertiesMode extends object_properties_mode,

1,146✔

530

>(

1,146✔

531

                properties_mode: PropertiesMode,

1,146✔

532

        ): object_schema<

1,146✔

533

                PropertiesMode

1,146✔

534

        >['required'] {

1,146✔

535

                const values_for_properties_mode: {

1,146✔

536

                        neither: readonly string[],

1,146✔

537

                        both: readonly ['properties', 'patternProperties'],

1,146✔

538

                        properties: readonly ['properties'],

1,146✔

539

                        pattern: readonly ['patternProperties'],

1,146✔

540

                }[PropertiesMode] = {

1,146✔

541

                        neither: [] as readonly string[],

1,146✔

542

                        both: ['properties', 'patternProperties'] as const,

1,146✔

543

                        properties: ['properties'] as const,

1,146✔

544

                        pattern: ['patternProperties'] as const,

1,146✔

545

                }[properties_mode];

1,146✔

546

1,146✔

547

                const required: object_schema<

1,146✔

548

                        PropertiesMode

1,146✔

549

                >['required'] = [

1,146✔

550

                        ...['type'],

1,146✔

551

                        ...values_for_properties_mode,

1,146✔

552

                ] as object_schema<

1,146✔

553

                        PropertiesMode

1,146✔

554

                >['required'];

1,146✔

555

1,146✔

556

                return required;

1,146✔

557

1,146✔

558

19✔

559

        static generate_type_definition<

19✔

560

                PropertiesMode extends object_properties_mode,

1,142✔

561

                Defs extends SchemaObject,

1,142✔

562

                Required extends readonly [string, ...string[]],

1,142✔

563

                Properties extends ObjectOfSchemas,

1,142✔

564

                PatternProperties extends ObjectOfSchemas,

1,142✔

565

>({

1,142✔

566

                properties_mode,

1,142✔

567

                $defs,

1,142✔

568

                required,

1,142✔

569

                properties,

1,142✔

570

                patternProperties,

1,142✔

571

        }: {

1,142✔

572

                properties_mode: PropertiesMode,

1,142✔

573

                $defs?: Defs,

1,142✔

574

                required?: Required,

1,142✔

575

                properties?: Properties,

1,142✔

576

                patternProperties?: PatternProperties,

1,142✔

577

        }): Readonly<object_type_base<

1,142✔

578

                PropertiesMode,

1,142✔

579

                Defs,

1,142✔

580

                Required,

1,142✔

581

                Properties,

1,142✔

582

                PatternProperties

1,142✔

583

        >> {

1,142✔

584

                const partial: Partial<object_type_base<

1,142✔

585

                        'both',

1,142✔

586

                        Defs,

1,142✔

587

                        Required,

1,142✔

588

                        Properties,

1,142✔

589

                        PatternProperties

1,142✔

590

                >> = {

1,142✔

591

                        type: 'object',

1,142✔

592

};

1,142✔

593

1,142✔

594

                if ($defs) {

1,142✔

595

                        partial.$defs = $defs;

8✔

596

8✔

597

1,142✔

598

                if (required) {

1,142✔

599

                        partial.required = required;

4✔

600

4✔

601

1,142✔

602

                if ('both' === properties_mode || 'properties' === properties_mode) {

1,142✔

603

                        partial.properties = properties;

580✔

604

580✔

605

1,142✔

606

                if (

1,142✔

607

                        'both' === properties_mode

1,142✔

608

                        || 'pattern' === properties_mode

1,142✔

609

) {

1,142✔

610

                        partial.patternProperties = patternProperties;

560✔

611

560✔

612

1,142✔

613

                const frozen = Object.freeze(partial as object_type_base<

1,142✔

614

                        PropertiesMode,

1,142✔

615

                        Defs,

1,142✔

616

                        Required,

1,142✔

617

                        Properties,

1,142✔

618

                        PatternProperties

1,142✔

619

>);

1,142✔

620

1,142✔

621

                return frozen;

1,142✔

622

1,142✔

623

19✔

624

        static #is_schema_with_some_type_of_properties<

19✔

625

                Defs extends SchemaObject,

34✔

626

                Required extends readonly [string, ...string[]],

34✔

627

                Properties extends ObjectOfSchemas,

34✔

628

                PatternProperties extends ObjectOfSchemas,

34✔

629

>(

34✔

630

                schema: object_type<

34✔

631

                        object_properties_mode,

34✔

632

                        Defs,

34✔

633

                        Required,

34✔

634

                        Properties,

34✔

635

                        PatternProperties

34✔

636

>,

34✔

637

        ): schema is object_type<

34✔

638

                'both'|'properties'|'pattern',

34✔

639

                Defs,

34✔

640

                Required,

34✔

641

                Properties,

34✔

642

                PatternProperties

34✔

643

> {

34✔

644

                return ('properties' in schema) || ('patternProperties' in schema);

34✔

645

34✔

646

19✔

647

        static #is_schema_with_properties<

19✔

648

                Defs extends SchemaObject,

1,006✔

649

                Required extends readonly [string, ...string[]],

1,006✔

650

                Properties extends ObjectOfSchemas,

1,006✔

651

                PatternProperties extends ObjectOfSchemas,

1,006✔

652

>(

1,006✔

653

                schema: SchemaObject|object_type<

1,006✔

654

                        object_properties_mode,

1,006✔

655

                        Defs,

1,006✔

656

                        Required,

1,006✔

657

                        Properties,

1,006✔

658

                        PatternProperties

1,006✔

659

>,

1,006✔

660

        ): schema is object_type_base<

1,006✔

661

                'both' | 'properties',

1,006✔

662

                Defs,

1,006✔

663

                Required,

1,006✔

664

                Properties,

1,006✔

665

                PatternProperties

1,006✔

666

> {

1,006✔

667

                return 'properties' in schema;

1,006✔

668

1,006✔

669

19✔

670

        static #is_schema_with_pattern_properties<

19✔

671

                Defs extends SchemaObject,

781✔

672

                Required extends readonly [string, ...string[]],

781✔

673

                Properties extends ObjectOfSchemas,

781✔

674

                PatternProperties extends ObjectOfSchemas,

781✔

675

>(

781✔

676

                schema: SchemaObject|object_type<

781✔

677

                        object_properties_mode,

781✔

678

                        Defs,

781✔

679

                        Required,

781✔

680

                        Properties,

781✔

681

                        PatternProperties

781✔

682

>,

781✔

683

        ): schema is object_type_base<

781✔

684

                'both'|'pattern',

781✔

685

                Defs,

781✔

686

                Required,

781✔

687

                Properties,

781✔

688

                PatternProperties

781✔

689

> {

781✔

690

                return 'patternProperties' in schema;

781✔

691

781✔

692

19✔

693

        static #is_schema_with_required<

19✔

694

                Required extends readonly [string, ...string[]],

33✔

695

>(

33✔

696

                schema: object_type<

33✔

697

                        object_properties_mode,

33✔

698

                        SchemaObject,

33✔

699

                        Required,

33✔

700

                        ObjectOfSchemas,

33✔

701

                        ObjectOfSchemas

33✔

702

>,

33✔

703

        ): schema is object_type<

33✔

704

                object_properties_mode,

33✔

705

                SchemaObject,

33✔

706

                Required,

33✔

707

                ObjectOfSchemas,

33✔

708

                ObjectOfSchemas

33✔

709

        > & {required: Required} {

33✔

710

                return 'required' in schema;

33✔

711

33✔

712

19✔

713

        static #convert<

19✔

714

T,

149✔

715

                PropertiesMode extends object_properties_mode,

149✔

716

                Defs extends SchemaObject,

149✔

717

                Required extends readonly [string, ...string[]],

149✔

718

                Properties extends ObjectOfSchemas,

149✔

719

                PatternProperties extends ObjectOfSchemas,

149✔

720

>(

149✔

721

                properties_mode: PropertiesMode,

149✔

722

                value: unknown,

149✔

723

                property: string,

149✔

724

                schema: object_type<

149✔

725

                        PropertiesMode,

149✔

726

                        Defs,

149✔

727

                        Required,

149✔

728

                        Properties,

149✔

729

                        PatternProperties

149✔

730

>,

149✔

731

                schema_parser: SchemaParser,

149✔

732

) {

149✔

733

                const sub_schema = this.#sub_schema_for_property(

149✔

734

                        schema_parser,

149✔

735

                        properties_mode,

149✔

736

                        property,

149✔

737

                        schema,

149✔

738

{},

149✔

739

);

149✔

740

149✔

741

                let maybe_modified = ObjectUnspecified.maybe_add_$defs(

149✔

742

                        schema,

149✔

743

                        sub_schema,

149✔

744

);

149✔

745

149✔

746

                const ajv = schema_parser.share_ajv((ajv) => ajv);

149✔

747

                const validator = ajv.compile<T>(maybe_modified);

149✔

748

149✔

749

                if (!(validator(value))) {

149✔

750

                        throw new TypeError('Supplied value not supported by property!');

30✔

751

30✔

752

115✔

753

                if (0 === Object.keys(sub_schema).length) {

149✔

754

                        maybe_modified = {

4✔

755

                                type: 'object',

4✔

756

                                additionalProperties: false,

4✔

757

                                maxProperties: 0,

4✔

758

};

4✔

759

4✔

760

115✔

761

                const instance = schema_parser.parse(

115✔

762

                        maybe_modified,

115✔

763

);

115✔

764

115✔

765

                return instance.generate_typescript_data(

115✔

766

                        value,

115✔

767

                        schema_parser,

115✔

768

                        maybe_modified,

115✔

769

);

115✔

770

149✔

771

19✔

772

        static #createObjectLiteralExpression<

19✔

773

                T extends {[key: string]: unknown},

80✔

774

                PropertiesMode extends object_properties_mode,

80✔

775

                Defs extends SchemaObject,

80✔

776

                Required extends readonly [string, ...string[]],

80✔

777

                Properties extends ObjectOfSchemas,

80✔

778

                PatternProperties extends ObjectOfSchemas,

80✔

779

>(

80✔

780

                properties_mode: PropertiesMode,

80✔

781

                data: T,

80✔

782

                schema: object_type<

80✔

783

                        PropertiesMode,

80✔

784

                        Defs,

80✔

785

                        Required,

80✔

786

                        Properties,

80✔

787

                        PatternProperties

80✔

788

>,

80✔

789

                schema_parser: SchemaParser,

80✔

790

                adjust_name: adjust_name_callback,

80✔

791

        ): ObjectLiteralExpression {

80✔

792

                return factory.createObjectLiteralExpression(

80✔

793

                        Object.entries(

80✔

794

                                data,

80✔

795

                        ).map(([

80✔

796

                                property,

149✔

797

                                value,

149✔

798

                        ]) => {

149✔

799

                                const type = this.#convert(

149✔

800

                                        properties_mode,

149✔

801

                                        value,

149✔

802

                                        property,

149✔

803

                                        schema,

149✔

804

                                        schema_parser,

149✔

805

);

149✔

806

149✔

807

                                return factory.createPropertyAssignment(

149✔

808

                                        adjust_name(property),

149✔

809

                                        type,

149✔

810

);

149✔

811

}),

80✔

812

);

80✔

813

80✔

814

19✔

815

        static async #createTypeNode<

19✔

816

                PropertiesMode extends object_properties_mode,

34✔

817

                Defs extends SchemaObject,

34✔

818

                Required extends readonly [string, ...string[]],

34✔

819

                Properties extends ObjectOfSchemas,

34✔

820

                PatternProperties extends ObjectOfSchemas,

34✔

821

>(

34✔

822

                properties_mode: PropertiesMode,

34✔

823

                schema: object_type<

34✔

824

                        PropertiesMode,

34✔

825

                        Defs,

34✔

826

                        Required,

34✔

827

                        Properties,

34✔

828

                        PatternProperties

34✔

829

>,

34✔

830

                schema_parser: SchemaParser,

34✔

831

        ): Promise<object_TypeLiteralNode<PropertiesMode>> {

34✔

832

                if (!this.#is_schema_with_some_type_of_properties(schema)) {

34✔

833

                        return factory.createTypeLiteralNode([

4✔

834

                                factory.createIndexSignature(

4✔

835

                                        undefined,

4✔

836

4✔

837

                                                factory.createParameterDeclaration(

4✔

838

                                                        undefined,

4✔

839

                                                        undefined,

4✔

840

                                                        factory.createIdentifier('key'),

4✔

841

                                                        undefined,

4✔

842

                                                        factory.createToken(SyntaxKind.StringKeyword),

4✔

843

),

4✔

844

],

4✔

845

                                        factory.createToken(SyntaxKind.UnknownKeyword),

4✔

846

),

4✔

847

                        ]) as object_TypeLiteralNode<PropertiesMode>;

4✔

848

4✔

849

30✔

850

                let properties: PropertySignature[] = [];

30✔

851

                let patterned: [TypeNode, ...TypeNode[]]|never[] = [];

30✔

852

30✔

853

                if (this.#is_schema_with_properties(schema)) {

34✔

854

                        properties = await Promise.all(Object.keys(

26✔

855

                                schema.properties,

26✔

856

                        ).map(async (

26✔

857

                                property,

33✔

858

                        ): Promise<PropertySignature> => factory.createPropertySignature(

33✔

859

                                undefined,

33✔

860

33✔

861

                                        /[?[\] ]/.test(property)

33✔

862

                                                ? factory.createComputedPropertyName(

33✔

863

                                                        factory.createStringLiteral(property),

2✔

864

2✔

865

                                                : property

33✔

866

),

33✔

867

33✔

868

33✔

869

                                                this.#is_schema_with_required(schema)

33✔

870

                                                && schema.required.includes(property)

33✔

871

33✔

872

                                                ? undefined

33✔

873

                                                : factory.createToken(SyntaxKind.QuestionToken)

33✔

874

),

33✔

875

                                await this.#generate_type(

33✔

876

                                        properties_mode,

33✔

877

                                        property,

33✔

878

                                        schema,

33✔

879

                                        schema_parser,

33✔

880

),

33✔

881

                        )));

26✔

882

26✔

883

30✔

884

                if (this.#is_schema_with_pattern_properties(schema)) {

34✔

885

                        patterned = await Promise.all(

6✔

886

6✔

887

                                        Object.values(

6✔

888

                                                schema.patternProperties,

6✔

889

6✔

890

                                ).map(

6✔

891

                                        (sub_schema) => {

6✔

892

                                                return schema_parser.parse(

10✔

893

                                                        ObjectUnspecified.maybe_add_$defs(

10✔

894

                                                                schema,

10✔

895

                                                                sub_schema,

10✔

896

),

10✔

897

                                                ).generate_typescript_type({

10✔

898

                                                        data: sub_schema,

10✔

899

                                                        schema: sub_schema,

10✔

900

                                                        schema_parser,

10✔

901

});

10✔

902

},

6✔

903

),

6✔

904

);

6✔

905

6✔

906

30✔

907

                let result: object_TypeLiteralNode<

30✔

908

                        Exclude<

30✔

909

                                object_properties_mode,

30✔

910

                                'neither'

30✔

911

30✔

912

>;

30✔

913

30✔

914

                if (properties.length > 0 && patterned.length > 0) {

34✔

915

                        result = factory.createIntersectionTypeNode([

2✔

916

                                factory.createTypeLiteralNode(properties),

2✔

917

                                this.#patterned_literal_node(

2✔

918

                                        patterned as [TypeNode, ...TypeNode[]],

2✔

919

),

2✔

920

]);

2✔

921

                } else if (properties.length > 0) {

34✔

922

                        result = factory.createTypeLiteralNode(properties);

24✔

923

                } else {

28✔

924

                        result = this.#patterned_literal_node(

4✔

925

                                patterned as [TypeNode, ...TypeNode[]],

4✔

926

);

4✔

927

4✔

928

30✔

929

                return result as object_TypeLiteralNode<PropertiesMode>;

30✔

930

34✔

931

19✔

932

        static async #generate_type<

19✔

933

                PropertiesMode extends object_properties_mode,

33✔

934

                Defs extends SchemaObject,

33✔

935

                Required extends readonly [string, ...string[]],

33✔

936

                Properties extends ObjectOfSchemas,

33✔

937

                PatternProperties extends ObjectOfSchemas,

33✔

938

>(

33✔

939

                properties_mode: PropertiesMode,

33✔

940

                property: string,

33✔

941

                schema: object_type<

33✔

942

                        PropertiesMode,

33✔

943

                        Defs,

33✔

944

                        Required,

33✔

945

                        Properties,

33✔

946

                        PatternProperties

33✔

947

>,

33✔

948

                schema_parser: SchemaParser,

33✔

949

) {

33✔

950

                const sub_schema = this.#sub_schema_for_property(

33✔

951

                        schema_parser,

33✔

952

                        properties_mode,

33✔

953

                        property,

33✔

954

                        schema,

33✔

955

{},

33✔

956

);

33✔

957

33✔

958

                let matched: (

33✔

959

                        | undefined

33✔

960

                        | Type<unknown>

33✔

961

                ) = schema_parser.maybe_parse_by_type<

33✔

962

                        $ref

33✔

963

>(

33✔

964

                        sub_schema,

33✔

965

33✔

966

                                maybe: unknown,

166✔

967

                        ): maybe is $ref => {

166✔

968

                                return $ref.is_a(maybe);

166✔

969

},

33✔

970

);

33✔

971

33✔

972

                if (undefined === matched) {

33✔

973

                        matched = schema_parser.parse(sub_schema);

19✔

974

                } else {

33✔

975

                        return matched.generate_typescript_type({

14✔

976

                                data: sub_schema,

14✔

977

                                schema: sub_schema,

14✔

978

                                schema_parser,

14✔

979

});

14✔

980

14✔

981

19✔

982

                return matched.generate_typescript_type({

19✔

983

                        schema: sub_schema,

19✔

984

                        schema_parser,

19✔

985

});

19✔

986

33✔

987

19✔

988

        static #patterned_literal_node(

19✔

989

                value: [TypeNode, ...TypeNode[]],

6✔

990

        ): TypeLiteralNode<IndexSignatureDeclaration> {

6✔

991

                return factory.createTypeLiteralNode([

6✔

992

                        factory.createIndexSignature(

6✔

993

                                undefined,

6✔

994

6✔

995

                                        factory.createParameterDeclaration(

6✔

996

                                                undefined,

6✔

997

                                                undefined,

6✔

998

                                                'key',

6✔

999

                                                undefined,

6✔

1000

                                                factory.createKeywordTypeNode(

6✔

1001

                                                        SyntaxKind.StringKeyword,

6✔

1002

),

6✔

1003

                                                undefined,

6✔

1004

),

6✔

1005

],

6✔

1006

                                1 === value.length

6✔

1007

                                        ? value[0]

6✔

1008

                                        : factory.createUnionTypeNode(

6✔

1009

                                                value as [TypeNode, TypeNode, ...TypeNode[]],

4✔

1010

),

6✔

1011

),

6✔

1012

]);

6✔

1013

6✔

1014

19✔

1015

        static #sub_schema_for_property<

19✔

1016

                PropertiesMode extends object_properties_mode,

228✔

1017

                Defs extends SchemaObject,

228✔

1018

                Required extends readonly [string, ...string[]],

228✔

1019

                Properties extends ObjectOfSchemas,

228✔

1020

                PatternProperties extends ObjectOfSchemas,

228✔

1021

>(

228✔

1022

                schema_parser: SchemaParser,

228✔

1023

                properties_mode: PropertiesMode,

228✔

1024

                property: string,

228✔

1025

                schema: SchemaObject|object_type<

228✔

1026

                        PropertiesMode,

228✔

1027

                        Defs,

228✔

1028

                        Required,

228✔

1029

                        Properties,

228✔

1030

                        PatternProperties

228✔

1031

>,

228✔

1032

                fallback_if_neither: Record<string, never>|unknown_type,

228✔

1033

        ): SchemaObject {

228✔

1034

                if (

228✔

1035

                        !this.#is_schema_with_pattern_properties(schema)

228✔

1036

                        && !this.#is_schema_with_properties(schema)

228✔

1037

                        && '$ref' in schema

228✔

1038

) {

228✔

1039

                        const maybe = this.#sub_schema_for_property_resolve_$ref(

50✔

1040

                                schema_parser,

50✔

1041

                                schema as SchemaObject & {

50✔

1042

                                        $ref: string,

50✔

1043

},

50✔

1044

);

50✔

1045

50✔

1046

                        if (maybe) {

50✔

1047

                                schema = maybe;

50✔

1048

50✔

1049

50✔

1050

228✔

1051

                if (

228✔

1052

                        !this.#is_schema_with_pattern_properties(schema)

228✔

1053

                        && !this.#is_schema_with_properties(schema)

228✔

1054

                        && 'string' === typeof schema.$ref

228✔

1070

                } else if (

228✔

1071

                        !this.#is_schema_with_pattern_properties(schema)

228✔

1072

                        && !this.#is_schema_with_properties(schema)

228✔

1073

                        && 'allOf' in schema

228✔

1074

                        && undefined !== schema.allOf

228✔

1075

                        && 2 === Object.keys(schema).length

228✔

1076

                        && '$defs' in schema

228✔

1077

) {

228✔

1078

                        const matching = this.#sub_schema_for_property_from_allOf(

15✔

1079

                                schema_parser,

15✔

1080

                                properties_mode,

15✔

1081

                                property,

15✔

1082

                                schema as SchemaObject & {

15✔

1083

                                        allOf: [

15✔

1084

                                                SchemaObject,

15✔

1085

                                                SchemaObject,

15✔

1086

                                                ...SchemaObject[],

15✔

1087

],

15✔

1088

},

15✔

1089

                                fallback_if_neither,

15✔

1090

);

15✔

1091

15✔

1092

                        if (matching) {

15✔

1093

                                return matching;

14✔

1094

14✔

1095

1✔

1096

                        throw new TypeError(

1✔

1097

                                `Property "${property}" has no match on the specified schema!`,

1✔

1098

);

1✔

1099

1✔

1100

213✔

1101

                if (

213✔

1102

                        this.#is_schema_with_properties(schema)

213✔

1103

                        && !(property in schema.properties)

228✔

1104

                        && 'string' === typeof schema?.$ref

228✔

1105

) {

228✔

1106

                        let checking_schema: (

28✔

1107

                                | SchemaObject

28✔

1108

                                | undefined

28✔

1109

                        ) = schema;

28✔

1110

28✔

1111

                        while (

28✔

1112

                                undefined !== checking_schema

28✔

1113

                                && !(property in checking_schema.properties)

28✔

1114

                                && 'string' === typeof checking_schema.$ref

28✔

1115

) {

28✔

1116

                                checking_schema = this.#sub_schema_for_property_resolve_$ref(

52✔

1117

                                        schema_parser,

52✔

1118

                                        checking_schema as SchemaObject & {

52✔

1119

                                                $ref: string,

52✔

1120

},

52✔

1121

);

52✔

1122

52✔

1123

                                if (

52✔

1124

                                        checking_schema

52✔

1125

                                        && 'allOf' in checking_schema

52✔

1126

                                        && undefined !== checking_schema.allOf

52✔

1127

) {

52✔

1128

                                        const matching = this.#sub_schema_for_property_from_allOf(

8✔

1129

                                                schema_parser,

8✔

1130

                                                properties_mode,

8✔

1131

                                                property,

8✔

1132

                                                checking_schema as SchemaObject & {

8✔

1133

                                                        allOf: [

8✔

1134

                                                                SchemaObject,

8✔

1135

                                                                SchemaObject,

8✔

1136

                                                                ...SchemaObject[],

8✔

1137

],

8✔

1138

},

8✔

1139

                                                fallback_if_neither,

8✔

1140

);

8✔

1141

8✔

1142

                                        if (matching) {

8✔

1143

                                                return matching;

8✔

1144

8✔

1145

8✔

1146

52✔

1147

20✔

1148

                        if (checking_schema !== undefined) {

28✔

1149

                                const maybe_type = schema_parser.parse_by_type<

18✔

1150

                                        ObjectUnspecified<

18✔

1151

                                                {[key: string]: unknown},

18✔

1152

                                                'properties'

18✔

1153

18✔

1154

>(

18✔

1155

                                        checking_schema,

18✔

1156

                                        (maybe): maybe is ObjectUnspecified<

18✔

1157

                                                {[key: string]: unknown},

18✔

1158

                                                'properties'

18✔

1159

                                        > => ObjectUnspecified.is_a<ObjectUnspecified<

18✔

1160

                                                {[key: string]: unknown},

18✔

1161

                                                'properties'

18✔

1162

                                        >>(maybe) && 'properties' === maybe.properties_mode,

18✔

1163

);

18✔

1164

18✔

1165

                                if (maybe_type && maybe_type.check_type(checking_schema)) {

18✔

1166

                                        schema = checking_schema as typeof schema;

18✔

1167

18✔

1168

18✔

1169

28✔

1170

205✔

1171

                if (

205✔

1172

                        this.#is_schema_with_properties(schema)

205✔

1173

                        && property in schema.properties

228✔

1174

                        && undefined !== schema.properties[property]

228✔

1175

) {

228✔

1176

                        return this.maybe_add_$defs(

138✔

1177

                                schema,

138✔

1178

                                schema.properties[property],

138✔

1179

);

138✔

1180

138✔

1181

67✔

1182

                if (

67✔

1183

                        this.#is_schema_with_pattern_properties(schema)

67✔

1184

) {

225✔

1185

                        const matching = Object.keys(

36✔

1186

                                schema.patternProperties,

36✔

1187

                        ).find((maybe) => {

36✔

1188

                                return (

52✔

1189

                                        (new RegExp(maybe)).test(property)

52✔

1190

                                        && undefined !== schema.patternProperties[maybe]

52✔

1191

);

52✔

1192

});

36✔

1193

36✔

1194

                        if (matching) {

36✔

1195

                                return schema.patternProperties[matching];

36✔

1196

36✔

1197

36✔

1198

31✔

1199

                if ('neither' === properties_mode) {

225✔

1200

                        return fallback_if_neither;

4✔

1201

4✔

1202

27✔

1203

                throw new TypeError(

27✔

1204

                        `Property "${property}" has no match on the specified schema!`,

27✔

1205

);

27✔

1206

228✔

1207

19✔

1208

        static #sub_schema_for_property_resolve_$ref(

19✔

1209

                schema_parser: SchemaParser,

102✔

1210

                schema: SchemaObject & {$ref: string},

102✔

1211

        ): SchemaObject|undefined {

102✔

1212

                if (!schema.$ref.startsWith('#/$defs/')) {

102✔

1213

                        const [

13✔

1214

                                other_schema_id,

13✔

1215

                                other_schema_ref_id,

13✔

1216

                        ] = schema.$ref.split(

13✔

1217

                                '#/$defs/',

13✔

1218

                        ) as [string, string];

13✔

1219

13✔

1220

                        const other_schema = schema_parser.get_schema(

13✔

1221

                                other_schema_id,

13✔

1222

);

13✔

1223

13✔

1224

                        if (

13✔

1225

                                other_schema

13✔

1226

                                && '$defs' in other_schema

13✔

1227

                                && undefined !== other_schema.$defs

13✔

1228

                                && other_schema_ref_id in other_schema.$defs

13✔

1229

) {

13✔

1230

                                return this.maybe_add_$defs(

12✔

1231

                                        other_schema,

12✔

1232

                                        other_schema.$defs[other_schema_ref_id],

12✔

1233

);

12✔

1234

12✔

1235

                } else {

102✔

1236

                        const $ref_id = schema.$ref.split('#/$defs/')[1];

89✔

1237

89✔

1238

                        if (

89✔

1239

                                '$defs' in schema

89✔

1240

                                && undefined !== schema.$defs

89✔

1241

                                && $ref_id in schema.$defs

89✔

1242

) {

89✔

1243

                                return this.maybe_add_$defs(

88✔

1244

                                        schema,

88✔

1245

                                        schema.$defs[$ref_id],

88✔

1246

);

88✔

1247

88✔

1248

89✔

1249

2✔

1250

                return undefined;

2✔

1251

102✔

1252

19✔

1253

        static #sub_schema_for_property_from_allOf<

19✔

1254

                PropertiesMode extends object_properties_mode,

23✔

1255

>(

23✔

1256

                schema_parser: SchemaParser,

23✔

1257

                properties_mode: PropertiesMode,

23✔

1258

                property: string,

23✔

1259

                schema: SchemaObject & {

23✔

1260

                        allOf: [

23✔

1261

                                SchemaObject,

23✔

1262

                                SchemaObject,

23✔

1263

                                ...SchemaObject[],

23✔

1264

],

23✔

1265

},

23✔

1266

                fallback_if_neither: Record<string, never>|unknown_type,

23✔

1267

        ): SchemaObject|undefined {

23✔

1268

                let matching: SchemaObject|undefined;

23✔

1269

23✔

1270

                for (const candidate of schema.allOf) {

23✔

1271

                        try {

46✔

1272

                                const maybe = this.#sub_schema_for_property(

46✔

1273

                                        schema_parser,

46✔

1274

                                        properties_mode,

46✔

1275

                                        property,

46✔

1276

                                        this.maybe_add_$defs(

46✔

1277

                                                schema,

46✔

1278

                                                candidate,

46✔

1279

),

46✔

1280

                                        fallback_if_neither,

46✔

1281

);

46✔

1282

46✔

1283

                                if (undefined !== maybe) {

46✔

1284

                                        matching = maybe;

22✔

1285

22✔

1286

                        // eslint-disable-next-line @typescript-eslint/no-unused-vars

46✔

1287

                        } catch (err) { /* empty */ }

46✔

1288

46✔

1289

23✔

1290

                return matching;

23✔

1291

23✔

1292

19✔

1293

19✔

1294

export type {

19✔

1295

        object_properties_mode,

19✔

1296

        object_type,

19✔

1297

        object_type_base,

19✔

1298

        object_schema,

19✔

1299

        object_TypeLiteralNode,

19✔

1300

        object_TypeLiteralNode_possibly_extended,

19✔

1301

};

19✔

1302

19✔

1303

export {

19✔

1304

        ObjectUnspecified,

19✔

1305

};

19✔

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19133596245

Source File
Press 'n' to go to next uncovered line, 'b' for previous

SignpostMarv / JSON-Schema-TypeScript-CodeGen / 19133596245

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous