@stainless-api/docs-ui 0.1.0-beta.2 → 0.1.0-beta.20

package/src/contexts/markdown.tsx

@@ -1,14 +1,14 @@
 import * as React from 'react';
 import { useLanguage } from './docs';
 
-const HighlightLanguageMappings = {
+const HighlightLanguageMappings: Record<string, string> = {
   node: 'typescript',
   http: 'bash',
 };
 
 export type MarkdownContext = {
-  highlight?: (content: string, language?: string) => string | Promise<string>;
-  render?: (content: string) => string;
+  highlight: (content: string, language: string) => string | Promise<string>;
+  render: (content: string) => string;
 };
 
 export const MarkdownContext = React.createContext<MarkdownContext>({
@@ -23,15 +23,16 @@ export function useRenderMarkdown(content?: string) {
   return React.useMemo(() => (content ? render(content) : undefined), [content, render]);
 }
 
-export function useHighlight(content?: string, language?: string) {
+export function useHighlight(content: string, language?: string) {
   const { highlight } = React.useContext(MarkdownContext);
-  const lang = language ?? useLanguage();
+  const defaultLanguage = useLanguage();
+  const lang = language ?? defaultLanguage;
 
   return React.useMemo(() => {
     const highlightLanguage = HighlightLanguageMappings[lang] ?? lang;
     const rendered = highlight(content, highlightLanguage);
     return typeof rendered === 'string' ? rendered : React.use(rendered);
-  }, [content, language, highlight]);
+  }, [content, highlight, lang]);
 }
 
 export type MarkdownProviderProps = MarkdownContext & {

package/src/contexts/search.tsx

@@ -1,4 +1,5 @@
 import * as React from 'react';
+import { createStrictContext } from '../hooks/use-strict-context';
 import { search } from '../search/providers/algolia';
 import { SearchParams, SearchSettings } from '../search/types';
 
@@ -8,11 +9,9 @@ export type SearchContextType = {
   pageFind?: string;
 };
 
-const SearchContext = React.createContext<SearchContextType>(null);
+const [Provider, useSearchContext] = createStrictContext<SearchContextType>('SearchContext');
 
-export function useSearchContext() {
-  return React.useContext(SearchContext);
-}
+export { useSearchContext };
 
 export function useSearch() {
   const { settings } = useSearchContext();
@@ -24,5 +23,5 @@ export type SearchProviderProps = SearchContextType & {
 };
 
 export function SearchProvider({ children, ...props }: SearchProviderProps) {
-  return <SearchContext value={props}>{children}</SearchContext>;
+  return <Provider value={props}>{children}</Provider>;
 }

package/src/hooks/use-strict-context.tsx

@@ -0,0 +1,16 @@
+import React from 'react';
+
+export function createStrictContext<T>(displayName: string) {
+  const Context = React.createContext<T | null>(null);
+  Context.displayName = displayName;
+
+  function useStrictContext(): T {
+    const context = React.useContext(Context);
+    if (context === null) {
+      throw new Error(`use${displayName} must be used within a ${displayName}Provider`);
+    }
+    return context;
+  }
+
+  return [Context.Provider, useStrictContext] as const;
+}

package/src/languages/go.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type * as AST from '~/lib/json-spec-v2/GoAST';
+import { GoAST as AST } from '@stainless/sdk-json';
 
 import { useComponents } from '../contexts/use-components';
 import { useLanguageComponents } from '../contexts';
@@ -43,7 +43,7 @@ export function Type({ type }: TypeProps) {
 
       return (
         <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref}>{type.typeName}</SDKReference>
+          {type.$ref ? <SDKReference stainlessPath={type.$ref}>{type.typeName}</SDKReference> : type.typeName}
           {params && params.length > 0 ? (
             <>
               <span className={style.TypeBracket}>{'['}</span>
@@ -179,7 +179,7 @@ export function MethodSignature({ decl }: MethodSignatureProps) {
 
 export type PropertyProps = {
   decl: AST.GoDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {

package/src/languages/http.tsx

@@ -1,4 +1,4 @@
-import type * as AST from '~/lib/json-spec-v2/HttpAST';
+import { HttpAST as AST } from '@stainless/sdk-json';
 import { useDeclaration, useLanguage, useLanguageComponents, useSpec } from '../contexts';
 import { useComponents } from '../contexts/use-components';
 import style from '../style';
@@ -11,7 +11,7 @@ const ComplexTypes: Partial<Record<AST.HttpType['kind'], string>> = {
   HttpTypeIntersection: 'intersection',
 };
 
-const constStyle = {
+const constStyle: Record<string, string> = {
   string: style.LiteralString,
   number: style.LiteralNumeric,
   boolean: style.LiteralBoolean,
@@ -34,17 +34,23 @@ function Identifier({ name }: { name: string }) {
 function TypePreview({ path }: { path: string }) {
   const spec = useSpec();
   const language = useLanguage();
-  const decl = useDeclaration(path);
+  const decl = useDeclaration(path, false);
   const { Join } = useComponents();
 
-  if (!(decl && 'children' in decl && decl.children.length > 0) || decl['type']?.['kind'] === 'HttpTypeUnion')
+  if (
+    !(decl && 'children' in decl && decl.children && decl.children.length > 0) ||
+    ('type' in decl && decl['type'] && 'kind' in decl['type'] && decl['type']['kind'] === 'HttpTypeUnion')
+  )
     return;
 
-  const items = decl.children.map((prop, key) => (
-    <span key={key} className={style.TypePropertyName}>
-      <span className={style.TextIdentifier}>{spec?.decls?.[language]?.[prop]?.['key']}</span>
-    </span>
-  ));
+  const items = decl.children.map((prop, key) => {
+    const decl = spec?.decls?.[language]?.[prop];
+    return (
+      <span key={key} className={style.TypePropertyName}>
+        <span className={style.TextIdentifier}>{decl && 'key' in decl ? decl?.['key'] : null}</span>
+      </span>
+    );
+  });
 
   return (
     <span className={style.TypePreview} data-stldocs-type-preview="properties">
@@ -138,7 +144,7 @@ export function Type({ type }: TypeProps) {
       if (
         name === 'Record' &&
         type.typeParameters?.length === 2 &&
-        type.typeParameters?.at(0).kind === 'HttpTypeString'
+        type.typeParameters?.at(0)!.kind === 'HttpTypeString'
       )
         return (
           <>
@@ -148,7 +154,7 @@ export function Type({ type }: TypeProps) {
 
       return (
         <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref}>{name}</SDKReference>
+          <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
           {params && params.length > 0 && (
             <>
               <span className={style.TypeBracket}>{'<'}</span>
@@ -158,14 +164,14 @@ export function Type({ type }: TypeProps) {
               <span className={style.TypeBracket}>{'>'}</span>
             </>
           )}
-          <TypePreview path={type.$ref} />
+          <TypePreview path={type.$ref!} />
         </span>
       );
     }
 
-    case 'HttpTypeObject':
+    case 'HttpTypeObject': {
       const items = type.members.map(({ ident }) => (
-        <span className={style.TypePropertyName}>
+        <span className={style.TypePropertyName} key={ident}>
           <Identifier name={ident} />
         </span>
       ));
@@ -185,6 +191,7 @@ export function Type({ type }: TypeProps) {
           </span>
         </span>
       );
+    }
   }
 }
 
@@ -193,28 +200,29 @@ export type MethodSignatureProps = {
 };
 
 export function MethodSignature({ decl }: MethodSignatureProps) {
+  void decl;
   return null;
 }
 
 export function MethodInfo({ decl, children }: MethodSignatureProps & { children: React.ReactNode }) {
   const Docs = useComponents();
 
-  const params = Object.entries(decl.paramsChildren)
-    .filter(([_, value]) => value.length)
+  const params = Object.entries(decl.paramsChildren!)
+    .filter(([, value]) => value.length)
     .map(([location, value]) => (
       <React.Fragment key={location}>
         <div className={style.MethodParameters} data-stldocs-property-group={location.at(0)}>
           <h5>
-            {location.at(0).toUpperCase()}
+            {location.at(0)!.toUpperCase()}
             {location.slice(1)} Parameters
-            <PropertyToggle target={location.at(0)} />
+            <PropertyToggle target={location.at(0)!} />
           </h5>
           <Docs.SDKChildren paths={value} />
         </div>
       </React.Fragment>
     ));
 
-  if (decl.bodyParamsChildren?.['application/json']?.length > 0)
+  if ((decl.bodyParamsChildren?.['application/json']?.length ?? 0) > 0)
     params.push(
       <div className={style.MethodInfoSection}>
         <h5>
@@ -222,7 +230,7 @@ export function MethodInfo({ decl, children }: MethodSignatureProps & { children
           <PropertyToggle target="body" />
         </h5>
         <div className={style.MethodParameters} data-stldocs-property-group="body">
-          <Docs.SDKChildren paths={decl.bodyParamsChildren?.['application/json']} />
+          <Docs.SDKChildren paths={decl.bodyParamsChildren?.['application/json'] ?? []} />
         </div>
       </div>,
     );
@@ -231,14 +239,14 @@ export function MethodInfo({ decl, children }: MethodSignatureProps & { children
     <div className={style.MethodInfo}>
       {children && <div className={style.MethodContent}>{children}</div>}
       {params.length > 0 && params}
-      {decl.responseChildren.length > 0 && (
+      {(decl.responseChildren?.length ?? 0) > 0 && (
         <div className={style.MethodInfoSection}>
           <h5>
             Returns
             <PropertyToggle target="returns" />
           </h5>
           <div className={style.MethodReturns} data-stldocs-property-group="returns">
-            <Docs.SDKChildren paths={decl.responseChildren} />
+            <Docs.SDKChildren paths={decl.responseChildren ?? []} />
           </div>
         </div>
       )}
@@ -256,7 +264,7 @@ function renderVariantInfo(type: AST.HttpType) {
 
 export type PropertyProps = {
   decl: AST.HttpDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {

package/src/languages/index.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from 'react';
-import type { DeclarationNode, Type } from '~/lib/json-spec-v2/types';
+import type { DeclarationNode, Type } from '@stainless/sdk-json';
 
 import * as typescript from './typescript';
 import * as java from './java';
@@ -17,10 +17,10 @@ export const kotlin = java;
 export type PropertyFn = (params: PropertyProps) => ReactNode;
 
 export interface LanguageComponentDefinition {
-  Declaration(props: { decl: DeclarationNode });
-  Property(props: { decl: DeclarationNode; children: PropertyFn });
-  TypeName(props: { type: Type; optional?: boolean });
-  Type(props: { type: Type; optional?: boolean });
-  MethodSignature(props: { decl: DeclarationNode });
-  MethodInfo?(props: { decl: DeclarationNode; children?: ReactNode });
+  Declaration(props: { decl: DeclarationNode }): ReactNode;
+  Property(props: { decl: DeclarationNode; children: PropertyFn }): ReactNode;
+  TypeName(props: { type: Type; optional?: boolean }): ReactNode;
+  Type(props: { type: Type; optional?: boolean }): ReactNode;
+  MethodSignature(props: { decl: DeclarationNode }): ReactNode;
+  MethodInfo?(props: { decl: DeclarationNode; children?: ReactNode }): ReactNode;
 }

package/src/languages/java.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type * as AST from '~/lib/json-spec-v2/JavaAST';
+import { JavaAST as AST } from '@stainless/sdk-json';
 
 import { useLanguage, useLanguageComponents } from '../contexts';
 import { useComponents } from '../contexts/use-components';
@@ -13,7 +13,7 @@ function showFullType(type: AST.JavaType) {
   );
 }
 
-const constStyle = {
+const constStyle: Record<string, string> = {
   string: style.LiteralString,
   number: style.LiteralNumeric,
   boolean: style.LiteralBoolean,
@@ -46,7 +46,7 @@ export function Type({ type, optional }: TypeProps) {
 
       return (
         <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref}>{name}</SDKReference>
+          <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
           {params && params.length > 0 ? (
             <>
               <span className={style.TypeBracket}>{'<'}</span>
@@ -186,7 +186,7 @@ export function MethodSignature({ decl }: MethodSignatureProps) {
 
 export type PropertyProps = {
   decl: AST.JavaDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {

package/src/languages/python.tsx

@@ -1,19 +1,21 @@
 import * as React from 'react';
-import type * as AST from '~/lib/json-spec-v2/PythonAST';
+import { PythonAST as AST } from '@stainless/sdk-json';
 import { useLanguageComponents } from '../contexts';
 import { useComponents } from '../contexts/use-components';
 import style from '../style';
 import { PropertyFn } from '.';
 
-const constStyle = {
+const constStyle: Record<string, string> = {
   string: style.LiteralString,
   number: style.LiteralNumeric,
   boolean: style.LiteralBoolean,
 };
 
-function showFullType(type: AST.PythonType) {
+function showFullType(type: AST.PythonType): boolean {
   if (type.kind !== 'PythonTypeReference') return false;
-  return type.typeName === 'Optional' ? showFullType(type.typeParameters[0]) : type.typeParameters.length > 0;
+  return type.typeName === 'Optional'
+    ? showFullType(type.typeParameters![0]!)
+    : type.typeParameters!.length > 0;
 }
 
 type TypeProps = {
@@ -26,7 +28,7 @@ export function TypeName({ type }: TypeProps) {
   if (type.kind === 'PythonTypeReference') {
     switch (type.typeName) {
       case 'Optional':
-        return <Lang.TypeName type={type.typeParameters[0]} />;
+        return <Lang.TypeName type={type.typeParameters![0]!} />;
       case 'List':
       case 'Iterable':
       case 'Literal':
@@ -64,7 +66,7 @@ export function Type({ type }: TypeProps) {
     case 'PythonTypeLiteral':
       return (
         <span className={style.Type}>
-          <span className={constStyle[typeof type.literal.value]}>{JSON.stringify(type.literal.value)}</span>
+          <span className={constStyle[typeof type.literal.value]!}>{JSON.stringify(type.literal.value)}</span>
         </span>
       );
 
@@ -97,7 +99,7 @@ export function Type({ type }: TypeProps) {
       return (
         <span className={style.Type}>
           <span className={type.typeName === 'Optional' ? style.TypeArray : ''}>
-            <SDKReference stainlessPath={type.$ref}>{type.typeName}</SDKReference>
+            <SDKReference stainlessPath={type.$ref!}>{type.typeName}</SDKReference>
           </span>
           {params && params.length > 0 && (
             <>
@@ -166,7 +168,7 @@ export function MethodSignature({ decl }: MethodSignatureProps) {
 
 export type PropertyProps = {
   decl: AST.PythonDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {
@@ -205,7 +207,7 @@ export function Declaration({ decl }: DeclarationProps) {
   if (!decl) return;
 
   switch (decl.kind) {
-    case 'PythonDeclProperty':
+    case 'PythonDeclProperty': {
       const nullable =
         decl.type.kind === 'PythonTypeReference' &&
         decl.type.typeName === 'Optional' &&
@@ -229,6 +231,7 @@ export function Declaration({ decl }: DeclarationProps) {
           )}
         </>
       );
+    }
 
     case 'PythonDeclClass':
       return (

package/src/languages/ruby.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type * as AST from '~/lib/json-spec-v2/RubyAST';
+import { RubyAST as AST } from '@stainless/sdk-json';
 import { useDeclaration, useLanguage, useLanguageComponents, useSpec } from '../contexts';
 import { useComponents } from '../contexts/use-components';
 import style from '../style';
@@ -36,17 +36,23 @@ const VALID_IDENTIFIER = /^[_A-Za-z][_A-Za-z0-9]*$/;
 function TypePreview({ path }: { path: string }) {
   const spec = useSpec();
   const language = useLanguage();
-  const decl = useDeclaration(path);
+  const decl = useDeclaration(path, false);
   const { Join } = useComponents();
 
-  if (!(decl && 'children' in decl && decl.children.length > 0) || decl['type']?.['kind'] === 'RubyTypeUnion')
+  if (
+    !(decl && 'children' in decl && decl.children && decl.children.length > 0) ||
+    ('type' in decl && decl['type'] && 'kind' in decl['type'] && decl['type']?.['kind'] === 'RubyTypeUnion')
+  )
     return;
 
-  const items = decl.children.map((prop, key) => (
-    <span key={key} className={style.TypePropertyName}>
-      <span className={style.TextIdentifier}>{spec?.decls?.[language]?.[prop]?.['ident']}</span>
-    </span>
-  ));
+  const items = decl.children.map((prop, key) => {
+    const p = spec?.decls?.[language]?.[prop];
+    return (
+      <span key={key} className={style.TypePropertyName}>
+        <span className={style.TextIdentifier}>{p && 'ident' in p ? p['ident'] : null}</span>
+      </span>
+    );
+  });
 
   return (
     <span className={style.TypePreview} data-stldocs-type-preview="properties">
@@ -110,6 +116,7 @@ export function Type({ type }: TypeProps) {
             </span>
           );
       }
+      break;
 
     case 'RubyTypeArray':
       return (
@@ -139,8 +146,8 @@ export function Type({ type }: TypeProps) {
       if (!type.typeParameters || type.typeParameters.length === 0)
         return (
           <span className={style.Type}>
-            <SDKReference stainlessPath={type.$ref}>{name}</SDKReference>
-            <TypePreview path={type.$ref} />
+            <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
+            <TypePreview path={type.$ref!} />
           </span>
         );
 
@@ -148,13 +155,13 @@ export function Type({ type }: TypeProps) {
 
       return (
         <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref}>{name}</SDKReference>
+          <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
           <span className={style.TypeBracket}>{'<'}</span>
           <Join items={typeParameters}>
             <span className={style.TextOperator}>, </span>
           </Join>
           <span className={style.TypeBracket}>{'>'}</span>
-          <TypePreview path={type.$ref} />
+          <TypePreview path={type.$ref!} />
         </span>
       );
     }
@@ -248,7 +255,7 @@ export function MethodSignature({ decl }: MethodSignatureProps) {
 
 export type PropertyProps = {
   decl: AST.RubyDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {

package/src/languages/typescript.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type * as TSAST from '~/lib/json-spec-v2/TSAST';
+import { TSAST } from '@stainless/sdk-json';
 import { useDeclaration, useLanguage, useLanguageComponents, useSpec } from '../contexts';
 import { useComponents } from '../contexts/use-components';
 import style from '../style';
@@ -13,7 +13,7 @@ const ComplexTypes: Record<string, string> = {
   TSTypeArray: 'array',
 };
 
-const constStyle = {
+const constStyle: Record<string, string> = {
   string: style.LiteralString,
   number: style.LiteralNumeric,
   boolean: style.LiteralBoolean,
@@ -66,17 +66,23 @@ function TypeParams({ params }: { params?: TSAST.TSTypeParameter[] }) {
 function TypePreview({ path }: { path: string }) {
   const spec = useSpec();
   const language = useLanguage();
-  const decl = useDeclaration(path);
+  const decl = useDeclaration(path, false);
   const { Join } = useComponents();
 
-  if (!(decl && 'children' in decl && decl.children.length > 0) || decl['type']?.['kind'] === 'TSTypeUnion')
+  if (
+    !(decl && 'children' in decl && decl.children && decl.children.length > 0) ||
+    (decl && 'type' in decl && 'kind' in decl['type'] && decl['type']['kind'] === 'TSTypeUnion')
+  )
     return;
 
-  const items = decl.children.map((prop, key) => (
-    <span key={key} className={style.TypePropertyName}>
-      <span className={style.TextIdentifier}>{spec?.decls?.[language]?.[prop]?.['key']}</span>
-    </span>
-  ));
+  const items = decl.children.map((prop, key) => {
+    const p = spec?.decls?.[language]?.[prop];
+    return (
+      <span key={key} className={style.TypePropertyName}>
+        <span className={style.TextIdentifier}>{p && 'key' in p ? p['key'] : null}</span>
+      </span>
+    );
+  });
 
   return (
     <span className={style.TypePreview} data-stldocs-type-preview="properties">
@@ -146,7 +152,7 @@ export function Type({ type }: TypeProps) {
 
       return (
         <span className={style.Type}>
-          <SDKReference stainlessPath={type.$ref}>{name}</SDKReference>
+          <SDKReference stainlessPath={type.$ref!}>{name}</SDKReference>
           {params && params.length > 0 && (
             <>
               <span className={style.TypeBracket}>{'<'}</span>
@@ -156,7 +162,7 @@ export function Type({ type }: TypeProps) {
               <span className={style.TypeBracket}>{'>'}</span>
             </>
           )}
-          <TypePreview path={type.$ref} />
+          <TypePreview path={type.$ref!} />
         </span>
       );
     }
@@ -274,7 +280,7 @@ export function MethodSignature({ decl }: MethodSignatureProps) {
 
 export type PropertyProps = {
   decl: TSAST.TSDeclaration;
-  children?: PropertyFn;
+  children: PropertyFn;
 };
 
 export function Property({ decl, children }: PropertyProps) {

package/src/markdown/index.ts

@@ -2,7 +2,7 @@ import Markdoc from '@markdoc/markdoc';
 import * as md from './md';
 import { EnvironmentType, getDecl, getSnippet, stripMarkup } from './utils';
 import * as printer from '../search/printer';
-import type * as SDKJSON from '~/lib/json-spec-v2/types';
+import type * as SDKJSON from '@stainless/sdk-json';
 import type { Node } from '@markdoc/markdoc';
 
 export function declaration(env: EnvironmentType, decl: SDKJSON.DeclarationNode) {
@@ -15,20 +15,20 @@ function renderChildren(env: EnvironmentType, children: SDKJSON.ID[], nesting: s
 }
 
 function renderDecl(env: EnvironmentType, path: string, nesting: string[] = []) {
-  const decl = getDecl(env, path);
+  const decl = getDecl(env, path)!;
   const item = md.item(declaration(env, decl));
 
-  const hasChildren = 'children' in decl && decl.children.length > 0;
-  const showModelProps = !decl['modelPath'] || env.options.includeModelProperties;
+  const hasChildren = 'children' in decl && decl.children && decl.children.length > 0;
+  const showModelProps = !('modelPath' in decl && decl['modelPath']) || env.options.includeModelProperties;
 
   if ('docstring' in decl && decl.docstring) item.children.push(...md.parse(decl.docstring));
   if (hasChildren && showModelProps && !nesting.includes(path))
-    item.push(renderChildren(env, decl.children, [...nesting, path]));
+    item.push(renderChildren(env, decl.children ?? [], [...nesting, path]));
 
   return item;
 }
 
-function renderMethod(env: EnvironmentType, method: SDKJSON.Method) {
+function renderMethod(env: EnvironmentType, method: SDKJSON.Method): Node[] {
   const decl = getDecl(env, method.stainlessPath);
 
   if (!decl)
@@ -41,11 +41,11 @@ function renderMethod(env: EnvironmentType, method: SDKJSON.Method) {
     ];
 
   const signature = printer.methodSignature(env.language, decl);
-  const [httpMethod, endpoint] = method.endpoint.split(' ');
+  const [httpMethod, endpoint] = method.endpoint.split(' ') as [string, string];
 
   const output = [
     md.heading(2, method.title),
-    env.language === 'http' ? null : md.paragraph(md.code(stripMarkup(signature))),
+    ...(env.language === 'http' ? [] : [md.paragraph(md.code(stripMarkup(signature)))]),
     md.paragraph(md.strong(md.text(httpMethod)), md.text(' '), md.code(endpoint)),
   ];
 
@@ -54,7 +54,7 @@ function renderMethod(env: EnvironmentType, method: SDKJSON.Method) {
   if ('paramsChildren' in decl && Array.isArray(decl.paramsChildren) && decl.paramsChildren.length > 0)
     output.push(md.heading(3, 'Parameters'), renderChildren(env, decl.paramsChildren));
 
-  if ('responseChildren' in decl && decl.responseChildren.length > 0)
+  if ('responseChildren' in decl && decl.responseChildren && decl.responseChildren.length > 0)
     output.push(md.heading(3, 'Returns'), renderChildren(env, decl.responseChildren));
 
   const snippet = getSnippet(env, method.stainlessPath);
@@ -67,7 +67,7 @@ function renderModel(env: EnvironmentType, model: SDKJSON.Model) {
   return [md.heading(3, model.title), md.list(renderDecl(env, `${model.stainlessPath} > (schema)`))];
 }
 
-function renderResource(env: EnvironmentType, resource: SDKJSON.Resource) {
+function renderResource(env: EnvironmentType, resource: SDKJSON.Resource): Node[] {
   const methods = Object.values(resource.methods)
     .filter((method) => getDecl(env, method.stainlessPath))
     .flatMap((method) => renderMethod(env, method));
@@ -82,11 +82,16 @@ function renderResource(env: EnvironmentType, resource: SDKJSON.Resource) {
 
   if (!env.options.renderNestedResources) return doc;
 
-  const children = Object.values(resource.subresources).map((resource) => renderResource(env, resource));
+  const children = Object.values(resource.subresources ?? {}).flatMap((resource) =>
+    renderResource(env, resource),
+  );
   return [...doc, ...children];
 }
 
-export function render(env: EnvironmentType, node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model) {
+export function render(
+  env: EnvironmentType,
+  node: SDKJSON.Resource | SDKJSON.Method | SDKJSON.Model,
+): Node[] {
   switch (node.kind) {
     case 'resource':
       return renderResource(env, node);