chore: fix types

.changeset/every-coins-sell.md

···
+---
+"@hey-api/openapi-ts": patch
+---
+
+**parser**: expose OpenAPI extension keywords

packages/openapi-ts/src/ir/types.d.ts

···
 
 import type { IRMediaType } from './mediaType';
 
+/**
+ * OpenAPI Specification Extensions.
+ *
+ * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
+ */
+export interface SpecificationExtensions {
+  [extension: `x-${string}`]: unknown;
+}
+
 interface IRBodyObject {
   mediaType: string;
   /**
···
   schemas?: Record<string, IRSchemaObject>;
 }
 
-export interface IROperationObject {
-  [extension: `x-${string}`]: unknown;
+export interface IROperationObject extends SpecificationExtensions {
   body?: IRBodyObject;
   deprecated?: boolean;
   description?: string;
···
 }
 
 interface IRParameterObject
-  extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'> {
-  [extension: `x-${string}`]: unknown;
+  extends Pick<JsonSchemaDraft2020_12, 'deprecated' | 'description'>,
+    SpecificationExtensions {
   /**
    * Determines whether the parameter value SHOULD allow reserved characters, as defined by RFC3986 `:/?#[]@!$&'()*+,;=` to be included without percent-encoding. The default value is `false`. This property SHALL be ignored if the request body media type is not `application/x-www-form-urlencoded` or `multipart/form-data`. If a value is explicitly defined, then the value of `contentType` (implicit or explicit) SHALL be ignored.
    */
···
 
 interface IRSchemaObject
   extends Pick<
-    JsonSchemaDraft2020_12,
-    | '$ref'
-    | 'const'
-    | 'default'
-    | 'deprecated'
-    | 'description'
-    | 'exclusiveMaximum'
-    | 'exclusiveMinimum'
-    | 'maximum'
-    | 'maxItems'
-    | 'maxLength'
-    | 'minimum'
-    | 'minItems'
-    | 'minLength'
-    | 'pattern'
-    | 'required'
-    | 'title'
-    | 'example'
-  > {
-  [extension: `x-${string}`]: unknown;
+      JsonSchemaDraft2020_12,
+      | '$ref'
+      | 'const'
+      | 'default'
+      | 'deprecated'
+      | 'description'
+      | 'exclusiveMaximum'
+      | 'exclusiveMinimum'
+      | 'maximum'
+      | 'maxItems'
+      | 'maxLength'
+      | 'minimum'
+      | 'minItems'
+      | 'minLength'
+      | 'pattern'
+      | 'required'
+      | 'title'
+      | 'example'
+    >,
+    SpecificationExtensions {
   /**
    * If the schema is intended to be used as an object property, it can be
    * marked as read-only or write-only. This value controls whether the schema

packages/openapi-ts/src/openApi/2.0.x/parser/index.ts

···
   parseServers({ context });
 
   for (const path in context.spec.paths) {
-    if (path.startsWith('x-')) {
-      continue;
-    }
-
+    if (path.startsWith('x-')) continue;
     const pathItem = context.spec.paths[path as PathKeys]!;
 
     const finalPathItem = pathItem.$ref

packages/openapi-ts/src/openApi/2.0.x/parser/operation.ts

···
   });
 
   parseExtensions({
-    source: operation as Record<string, unknown>,
-    target: irOperation as Record<string, unknown>,
+    source: operation,
+    target: irOperation,
   });
 
   return irOperation;

packages/openapi-ts/src/openApi/2.0.x/parser/parameter.ts

···
   }
 
   parseExtensions({
-    source: parameter as Record<string, unknown>,
-    target: irParameter as Record<string, unknown>,
+    source: parameter,
+    target: irParameter,
   });
 
   return irParameter;

packages/openapi-ts/src/openApi/2.0.x/parser/schema.ts

···
   source,
   target,
 }: {
-  source: Record<string, unknown>;
-  target: Record<string, unknown>;
+  source: object;
+  target: object;
 }) => {
   for (const key in source) {
     if (key.startsWith('x-')) {
-      target[key] = source[key];
+      (target as Record<string, unknown>)[key] = (
+        source as Record<string, unknown>
+      )[key];
     }
   }
 };
···
   });
 
   parseExtensions({
-    source: schema as Record<string, unknown>,
-    target: irSchema as Record<string, unknown>,
+    source: schema,
+    target: irSchema,
   });
 
   return irSchema;

packages/openapi-ts/src/openApi/3.0.x/parser/index.ts

···
   parseServers({ context });
 
   for (const path in context.spec.paths) {
-    const pathItem = context.spec.paths[path as keyof PathsObject]!;
+    if (path.startsWith('x-')) continue;
+    const pathItem = context.spec.paths[
+      path as keyof PathsObject
+    ]! as PathItemObject;
 
     const finalPathItem = pathItem.$ref
       ? {
···
         servers: finalPathItem.servers,
         summary: finalPathItem.summary,
       },
-      path: path as keyof PathsObject,
+      path: path as `/${string}`,
       securitySchemesMap,
       state,
     };

packages/openapi-ts/src/openApi/3.0.x/parser/operation.ts

···
 import type {
   OperationObject,
   PathItemObject,
+  ReferenceObject,
   RequestBodyObject,
   ResponseObject,
   SecuritySchemeObject,
···
   });
 
   parseExtensions({
-    source: operation as Record<string, unknown>,
-    target: irOperation as Record<string, unknown>,
+    source: operation,
+    target: irOperation,
   });
 
   return irOperation;
···
   }
 
   for (const name in operation.responses) {
+    if (name.startsWith('x-')) continue;
+
     if (!irOperation.responses) {
       irOperation.responses = {};
     }
 
-    const response = operation.responses[name]!;
+    const response = operation.responses[name]! as
+      | ResponseObject
+      | ReferenceObject;
     const responseObject =
       '$ref' in response
         ? context.resolveRef<ResponseObject>(response.$ref)

packages/openapi-ts/src/openApi/3.0.x/parser/parameter.ts

···
   }
 
   parseExtensions({
-    source: parameter as Record<string, unknown>,
-    target: irParameter as Record<string, unknown>,
+    source: parameter,
+    target: irParameter,
   });
 
   return irParameter;

packages/openapi-ts/src/openApi/3.0.x/parser/schema.ts

···
   source,
   target,
 }: {
-  source: Record<string, unknown>;
-  target: Record<string, unknown>;
+  source: object;
+  target: object;
 }) => {
   for (const key in source) {
     if (key.startsWith('x-')) {
-      target[key] = source[key];
+      (target as Record<string, unknown>)[key] = (
+        source as Record<string, unknown>
+      )[key];
     }
   }
 };
···
   });
 
   parseExtensions({
-    source: schema as Record<string, unknown>,
-    target: irSchema as Record<string, unknown>,
+    source: schema,
+    target: irSchema,
   });
 
   return irSchema;

packages/openapi-ts/src/openApi/3.0.x/types/spec.d.ts

···
 import type { EnumExtensions } from '~/openApi/shared/types/openapi-spec-extensions';
 
 /**
- * Type for OpenAPI Specification Extensions (x-* fields).
+ * OpenAPI Specification Extensions.
+ *
  * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#specification-extensions Specification Extensions}.
  */
 export interface SpecificationExtensions {
···
  * version: 1.0.1
  * ```
  */
-export interface InfoObject {
+export interface InfoObject extends SpecificationExtensions {
   /**
    * The contact information for the exposed API.
    */
···
   /**
    * A relative path to an individual endpoint. The field name MUST begin with a forward slash (`/`). The path is **appended** (no relative URL resolution) to the expanded URL from the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#server-object Server Object}'s `url` field in order to construct the full URL. {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.4.md#path-templating Path templating} is allowed. When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts. Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical. In case of ambiguous matching, it's up to the tooling to decide which one to use.
    */
-  [path: `/${string}`]: PathItemObject | unknown;
+  [path: `/${string}`]: PathItemObject;
 }
 
 /**

packages/openapi-ts/src/openApi/3.1.x/parser/index.ts

···
   parseServers({ context });
 
   for (const path in context.spec.paths) {
-    const pathItem = context.spec.paths[path as keyof PathsObject]!;
+    if (path.startsWith('x-')) continue;
+    const pathItem = context.spec.paths[
+      path as keyof PathsObject
+    ]! as PathItemObject;
 
     const finalPathItem = pathItem.$ref
       ? {
···
         servers: finalPathItem.servers,
         summary: finalPathItem.summary,
       },
-      path: path as keyof PathsObject,
+      path: path as `/${string}`,
       securitySchemesMap,
       state,
     };

packages/openapi-ts/src/openApi/3.1.x/parser/operation.ts

···
 
 import type {
   OperationObject,
+  ReferenceObject,
   RequestBodyObject,
   ResponseObject,
   SecuritySchemeObject,
···
   });
 
   parseExtensions({
-    source: operation as Record<string, unknown>,
-    target: irOperation as Record<string, unknown>,
+    source: operation,
+    target: irOperation,
   });
 
   return irOperation;
···
   }
 
   for (const name in operation.responses) {
+    if (name.startsWith('x-')) continue;
+
     if (!irOperation.responses) {
       irOperation.responses = {};
     }
 
-    const response = operation.responses[name]!;
+    const response = operation.responses[name]! as
+      | ResponseObject
+      | ReferenceObject;
     const responseObject =
       '$ref' in response
         ? context.resolveRef<ResponseObject>(response.$ref)

packages/openapi-ts/src/openApi/3.1.x/parser/parameter.ts

···
   }
 
   parseExtensions({
-    source: parameter as Record<string, unknown>,
-    target: irParameter as Record<string, unknown>,
+    source: parameter,
+    target: irParameter,
   });
 
   return irParameter;

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts

···
   source,
   target,
 }: {
-  source: Record<string, unknown>;
-  target: Record<string, unknown>;
+  source: object;
+  target: object;
 }) => {
   for (const key in source) {
     if (key.startsWith('x-')) {
-      target[key] = source[key];
+      (target as Record<string, unknown>)[key] = (
+        source as Record<string, unknown>
+      )[key];
     }
   }
 };
···
   });
 
   parseExtensions({
-    source: schema as Record<string, unknown>,
-    target: irSchema as Record<string, unknown>,
+    source: schema,
+    target: irSchema,
   });
 
   return irSchema;

packages/openapi-ts/src/openApi/3.1.x/types/json-schema-draft-2020-12.d.ts

···
 import type { EnumExtensions } from '~/openApi/shared/types/openapi-spec-extensions';
 
 import type { MaybeArray } from '../../../types/utils';
+import type { SpecificationExtensions } from './spec';
 import type { OpenApiSchemaExtensions } from './spec-extensions';
-
-/**
- * Type for OpenAPI Specification Extensions (x-* fields).
- */
-export interface SpecificationExtensions {
-  [extension: `x-${string}`]: unknown;
-}
 
 // TODO: left out some keywords related to structuring a complex schema and declaring a dialect
 export interface JsonSchemaDraft2020_12

packages/openapi-ts/src/openApi/3.1.x/types/spec.d.ts

···
 import type { JsonSchemaDraft2020_12 } from './json-schema-draft-2020-12';
 
 /**
- * Type for OpenAPI Specification Extensions (x-* fields).
+ * OpenAPI Specification Extensions.
+ *
  * See {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}.
  */
 export interface SpecificationExtensions {
···
  *
  * will map to `Dog` because of the definition in the `mapping` element.
  */
-export interface DiscriminatorObject {
+export interface DiscriminatorObject extends SpecificationExtensions {
   /**
    * An object to hold mappings between payload values and schema names or references.
    */
···
   /**
    * A relative path to an individual endpoint. The field name MUST begin with a forward slash (`/`). The path is **appended** (no relative URL resolution) to the expanded URL from the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#server-object `Server Object`}'s `url` field in order to construct the full URL. {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#path-templating Path templating} is allowed. When matching URLs, concrete (non-templated) paths would be matched before their templated counterparts. Templated paths with the same hierarchy but different templated names MUST NOT exist as they are identical. In case of ambiguous matching, it's up to the tooling to decide which one to use.
    */
-  [path: `/${string}`]: PathItemObject | unknown;
+  [path: `/${string}`]: PathItemObject;
 }
 
 /**
···
  *
  * This object MAY be extended with {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#specification-extensions Specification Extensions}, though as noted, additional properties MAY omit the `x-` prefix within this object.
  */
-export type SchemaObject = JsonSchemaDraft2020_12;
+export type SchemaObject = JsonSchemaDraft2020_12 & SpecificationExtensions;
 
 /**
  * Lists the required security schemes to execute this operation. The name used for each property MUST correspond to a security scheme declared in the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#componentsSecuritySchemes Security Schemes} under the {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#components-object Components Object}.

packages/openapi-ts/src/openApi/shared/utils/patch.ts

···
         if (!schema || typeof schema !== 'object') continue;
 
         const patchFn = patchOptions.schemas[key]!;
-        patchFn(schema);
+        patchFn(schema as Parameters<typeof patchFn>[0]);
       }
     }
 

packages/openapi-ts/src/plugins/@hey-api/schemas/plugin.ts

···
         plugin,
         schema: item,
       }),
-    ) as
+    ) as unknown as
       | OpenApiV3_0_XTypes['SchemaObject']
       | OpenApiV3_0_XTypes['ReferenceObject'];
   }
···
         plugin,
         schema: item,
       }),
-    ) as OpenApiV3_1_XTypes['SchemaObject'];
+    ) as unknown as OpenApiV3_1_XTypes['SchemaObject'];
   }
 
   const schema = structuredClone(_schema);