@stainless-api/docs-ui 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/types/stainless-alias/lib/json-spec-v2/TSAST.d.ts

@@ -0,0 +1,146 @@
+import type * as SDKJSON from './types';
+export type TSDeclaration = TSDeclFunction | TSDeclClass | TSDeclInterface | TSDeclProperty | TSDeclTypeAlias | TSDeclReference | SDKJSON.ErrorDecl;
+export type TSDeclFunction = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclFunction';
+    ident: TSIdentifier;
+    qualified?: string;
+    signature: TSFunctionSignature;
+    overloads?: TSFunctionSignature[];
+    paramsChildren?: SDKJSON.ID[];
+    responseChildren?: SDKJSON.ID[];
+};
+export type TSDeclClass = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclClass';
+    ident: TSIdentifier;
+    docstring?: string;
+    typeParameters?: TSTypeParameter[];
+    superClass?: TSTypeReference;
+    implements?: TSTypeReference[];
+    children: SDKJSON.ID[];
+};
+export type TSDeclInterface = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclInterface';
+    ident: TSIdentifier;
+    docstring?: string;
+    typeParameters?: TSTypeParameter[];
+    extends?: TSType[];
+    children: SDKJSON.ID[];
+};
+export type TSDeclProperty = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclProperty';
+    key: string;
+    docstring?: string;
+    type: TSType;
+    constraints?: SDKJSON.Constraints;
+    optional?: boolean;
+    declare?: boolean;
+    default?: any;
+    schemaType?: SDKJSON.SchemaType;
+    modelPath?: string;
+    childrenParentSchema?: SDKJSON.SchemaType;
+    children?: SDKJSON.ID[];
+};
+export type TSDeclTypeAlias = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclTypeAlias';
+    docstring?: string;
+    ident: TSIdentifier;
+    typeParameters?: TSTypeParameter[];
+    type: TSType;
+    children?: SDKJSON.ID[];
+};
+export type TSDeclReference = SDKJSON.BaseDeclaration & {
+    kind: 'TSDeclReference';
+    docstring?: string;
+    type: TSType;
+    children?: SDKJSON.ID[];
+};
+export type TSFunctionSignature = {
+    kind: 'TSFunctionSignature';
+    parameters: TSFunctionParameter[];
+    returns: TSType;
+    async?: boolean;
+    typeParameters?: TSTypeParameter[];
+    docstring?: string;
+};
+export type TSFunctionParameter = {
+    kind: 'TSFunctionParameter';
+    ident: TSIdentifier;
+    type: TSType;
+    optional?: boolean;
+};
+export type TSTypeParameter = {
+    kind: 'TSTypeParameter';
+    name: TSIdentifier;
+    constraint?: TSType;
+    default?: TSType;
+};
+export type TSPropertyKey = TSIdentifier;
+export type TSIdentifier = string;
+export type TSType = TSTypeReference | TSTypeObject | TSTypeArray | TSTypeString | TSTypeNumber | TSTypeBoolean | TSTypeNull | TSTypeUndefined | TSTypeVoid | TSTypeAny | TSTypeUnknown | TSTypeNever | TSTypeLiteral | TSTypeUnion | TSTypeIntersection | TSTypeInterface;
+export type TSTypeReference = SDKJSON.BaseType & {
+    kind: 'TSTypeReference';
+    ident: TSIdentifier;
+    typeParameters?: TSType[];
+    schemaType?: SDKJSON.SchemaType;
+    $ref?: SDKJSON.ID;
+};
+export type TSTypeObject = SDKJSON.BaseType & {
+    kind: 'TSTypeObject';
+    members: {
+        ident: TSIdentifier;
+        type: TSType;
+        optional?: boolean;
+    }[];
+};
+export type TSTypeArray = SDKJSON.BaseType & {
+    kind: 'TSTypeArray';
+    elementType: TSType;
+};
+export type TSTypeUnion = SDKJSON.BaseType & {
+    kind: 'TSTypeUnion';
+    types: TSType[];
+};
+export type TSTypeIntersection = SDKJSON.BaseType & {
+    kind: 'TSTypeIntersection';
+    types: TSType[];
+};
+export type TSTypeInterface = SDKJSON.BaseType & {
+    kind: 'TSTypeInterface';
+    members: {
+        ident: TSIdentifier;
+        type: TSType;
+        optional?: boolean;
+    }[];
+    extends?: TSTypeReference[];
+};
+export type TSTypeLiteral = SDKJSON.BaseType & {
+    kind: 'TSTypeLiteral';
+    literal: string | boolean | number;
+};
+export type TSTypeString = SDKJSON.BaseType & {
+    kind: 'TSTypeString';
+};
+export type TSTypeNumber = SDKJSON.BaseType & {
+    kind: 'TSTypeNumber';
+};
+export type TSTypeBoolean = SDKJSON.BaseType & {
+    kind: 'TSTypeBoolean';
+};
+export type TSTypeNull = SDKJSON.BaseType & {
+    kind: 'TSTypeNull';
+};
+export type TSTypeUndefined = SDKJSON.BaseType & {
+    kind: 'TSTypeUndefined';
+};
+export type TSTypeVoid = SDKJSON.BaseType & {
+    kind: 'TSTypeVoid';
+};
+export type TSTypeAny = SDKJSON.BaseType & {
+    kind: 'TSTypeAny';
+};
+export type TSTypeUnknown = SDKJSON.BaseType & {
+    kind: 'TSTypeUnknown';
+};
+export type TSTypeNever = SDKJSON.BaseType & {
+    kind: 'TSTypeNever';
+};

package/dist/types/stainless-alias/lib/json-spec-v2/TSAST.js

@@ -0,0 +1,3 @@
+// This is loosely based upon the Babel AST for TypeScript.
+export {};
+//# sourceMappingURL=TSAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/TSAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TSAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/TSAST.ts"],"names":[],"mappings":"AAAA,2DAA2D"}

package/dist/types/stainless-alias/lib/json-spec-v2/TerraformAST.d.ts

@@ -0,0 +1,89 @@
+import type { Configurability, TerraformValidators } from '~/templates/TerraformSDK/terraform-types';
+import type * as SDKJSON from './types';
+export type TerraformNode = TerraformDeclaration;
+export type TerraformDeclaration = TerraformDeclServiceNode | TerraformDeclSource | TerraformDeclAttribute | SDKJSON.ErrorDecl;
+export type TerraformDeclServiceNode = SDKJSON.BaseDeclaration & {
+    kind: 'TerraformDeclServiceNode';
+    resource?: SDKJSON.ID;
+    dataSource?: SDKJSON.ID;
+    listDataSource?: SDKJSON.ID;
+};
+export type TerraformDeclSource = SDKJSON.BaseDeclaration & {
+    kind: 'TerraformDeclSource';
+    name: string;
+    type: 'resource' | 'datasource-plural' | 'datasource-single';
+    methodName: string;
+    required: SDKJSON.ID[];
+    optional: SDKJSON.ID[];
+    computed: SDKJSON.ID[];
+};
+export type PrimitiveNumberProps = {
+    oneof?: number[];
+    default: number | null;
+    minimum: number | null;
+    maximum: number | null;
+};
+export type Primitive = {
+    category: 'primitive';
+} & ({
+    type: 'Bool';
+    default: boolean | null;
+} | ({
+    type: 'Float64';
+} & PrimitiveNumberProps) | ({
+    type: 'Int64';
+} & PrimitiveNumberProps) | ({
+    type: 'Number';
+} & PrimitiveNumberProps) | {
+    type: 'Time';
+    default: string | null;
+} | {
+    type: 'String';
+    oneof?: string[];
+    default: string | null;
+});
+export type Dynamic = {
+    category: 'dynamic';
+    type: 'Dynamic';
+    allowedSubtypes: Primitive['type'][];
+};
+export type Unknown = {
+    category: 'unknown';
+    type: 'unknown';
+};
+export type Collection = {
+    category: 'collection';
+    type: 'List' | 'Map' | 'Set';
+    elementType: AttributeType;
+};
+export type Nested = {
+    category: 'nested';
+    type: 'ListNested' | 'MapNested' | 'SetNested' | 'SingleNested';
+    modelTypeName: string;
+    validators: TerraformValidators;
+};
+type MethodNames = 'create' | 'read' | 'list' | 'update' | 'delete';
+export type Timeouts = {
+    propertyName: string;
+    block: boolean;
+    type: 'resource' | 'datasource';
+    timeouts: {
+        [key in MethodNames]: number | undefined;
+    };
+};
+export type AttributeType = Nested | Collection | Dynamic | Primitive | Unknown;
+export type PathExpr = Readonly<{
+    path: string;
+    container?: Collection['type'] | Nested['type'];
+}>;
+export type PathExpression = readonly PathExpr[];
+export type TerraformDeclAttribute = SDKJSON.BaseDeclaration & {
+    kind: 'TerraformDeclAttribute';
+    name: string;
+    docstring?: string;
+    type: AttributeType;
+    children: SDKJSON.ID[];
+    configurability: Configurability;
+    requiresReplace?: boolean;
+};
+export {};

package/dist/types/stainless-alias/lib/json-spec-v2/TerraformAST.js

@@ -0,0 +1,3 @@
+// placeholder for now
+export {};
+//# sourceMappingURL=TerraformAST.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/TerraformAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TerraformAST.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/TerraformAST.ts"],"names":[],"mappings":"AAAA,sBAAsB"}

package/dist/types/stainless-alias/lib/json-spec-v2/types.d.ts

@@ -0,0 +1,190 @@
+import type { DiagnosticExport } from '@pkg/diagnostics/src/base';
+import type { ResponseContentObject, SchemaObject } from '@pkg/openapi';
+import type { Config, SupportedLanguage } from '@pkg/stainless-config';
+import type { HTTPMethod } from '@pkg/stainless-config/src/util';
+import type { HttpDeclaration, HttpDeclProperty, HttpDeclReference, HttpType } from '~/lib/json-spec-v2/HttpAST';
+import type { RubyDeclaration, RubyDeclProperty, RubyDeclReference, RubyType } from '~/lib/json-spec-v2/RubyAST';
+import type { SDKSchema, SDKSchemaType } from '~/lib/sdk-spec/generic-sdk-wrappers';
+import type { GoDeclaration, GoDeclConst, GoDeclProperty, GoDeclReference, GoType } from './GoAST';
+import type { JavaDeclaration, JavaDeclProperty, JavaDeclReference, JavaType } from './JavaAST';
+import type { PythonDeclaration, PythonDeclProperty, PythonDeclReference, PythonType } from './PythonAST';
+import type { TerraformDeclaration } from './TerraformAST';
+import type { TSDeclaration, TSDeclProperty, TSDeclReference, TSType } from './TSAST';
+export type HasOASRef = {
+    oasRef?: string;
+};
+export type HasConfigRef = {
+    configRef: string;
+};
+export type HasStainlessPath = {
+    stainlessPath: string;
+};
+export type ID = string & {
+    _isId: null;
+};
+export type SchemaType = SDKSchemaType;
+export declare const constraints: readonly ["minLength", "maxLength", "format", "minimum", "exclusiveMinimum", "maximum", "exclusiveMaximum", "multipleOf"];
+export type Constraints = Pick<SchemaObject, (typeof constraints)[number]>;
+export declare function constraintsFromSchema(rawSchema: SchemaObject): {
+    [k: string]: any;
+} | undefined;
+export declare const SpecLanguages: readonly ["node", "go", "python", "terraform", "http", "typescript", "ruby", "java", "kotlin"];
+export type SpecLanguage = (typeof SpecLanguages)[number];
+export declare function isSpecLanguage(language: string): language is SpecLanguage;
+export declare const SnippetLanguages: readonly ["node.default", "go.default", "python.default", "terraform.default", "http.curl", "http.powershell", "typescript.default", "ruby.default", "java.default", "kotlin.default"];
+export type SnippetLanguage<lang extends SpecLanguage = SpecLanguage> = (typeof SnippetLanguages)[number] & `${lang}.${string}`;
+/**
+ * A literal property path from Spec down to a given node
+ */
+export type Path = (string | number)[];
+/**
+ * A literal property path from Spec down to a given node
+ */
+export type PathLike = string | (string | number)[];
+export type Node = Spec | Resource | Method | Model;
+/**
+ * Checks if thing is an Node.
+ * Not a sound check, it should only be called on values within an
+ * tree, and it only works because no node has a property
+ * of type Record<string, string>.
+ */
+export declare function isNode(thing: any): thing is Node;
+export type DeclRefType = HttpDeclReference | TSDeclReference | PythonDeclReference | GoDeclReference | GoDeclConst | RubyDeclReference | JavaDeclReference;
+export type Type = HttpType | TSType | PythonType | GoType | RubyType | JavaType;
+export type PropertyType = HttpDeclProperty | TSDeclProperty | PythonDeclProperty | GoDeclProperty | RubyDeclProperty | JavaDeclProperty;
+export type Spec = {
+    name: string;
+    kind: 'spec';
+    security_schemes: {
+        type: 'http_bearer' | 'query' | 'header' | 'oauth2' | 'http_basic' | 'http_digest';
+        description?: string;
+        name: string;
+        title: string;
+        header: string | undefined;
+        example: string | undefined;
+    }[];
+    resources: Record<string, Resource>;
+    diagnostics: Diagnostics;
+    docs?: Config['docs'];
+    metadata: {
+        [lang in SpecLanguage]?: {
+            repo_url?: string;
+            code_url?: string;
+            package_title?: string;
+            version?: string;
+            install?: string;
+        };
+    };
+    readme: {
+        [lang in SpecLanguage]?: string;
+    };
+    decls: {
+        [lang in SpecLanguage]?: Record<string, LanguageDeclNodes[lang]>;
+    };
+    snippets: {
+        [key in SnippetLanguage]?: Record<string, string>;
+    };
+};
+export type Resource = (HasConfigRef & HasStainlessPath) & {
+    kind: 'resource';
+    name: string;
+    title: string;
+    configRef: string;
+    description?: string;
+    models: Record<string, Model>;
+    methods: Record<string, Method>;
+    subresources?: Record<string, Resource>;
+} & {
+    [key in SpecLanguage]?: {
+        Name: string;
+        QualifiedName: string;
+    };
+};
+export type Method = (HasStainlessPath & HasOASRef) & {
+    kind: 'http_method';
+    name: string;
+    title: string;
+    configRef: string | undefined;
+    description?: string;
+    summary?: string;
+    httpMethod: string;
+    endpoint: string;
+    deprecated?: string | boolean;
+    exampleResponses?: Record<string, ResponseContentObject>;
+    security: Record<string, string[]>[] | undefined;
+    'x-api-token-group'?: string[];
+} & {
+    [key in SpecLanguage]?: {
+        Name: string;
+        QualifiedName: string;
+    };
+};
+export type StainlessMethodInfo = StainlessHttpMethodInfo | StainlessAliasMethodInfo | StainlessWebhookUnwrapMethodInfo;
+export type StainlessHttpMethodInfo = {
+    kind: 'http_method_info';
+    httpMethod: HTTPMethod;
+    path: string;
+};
+export type StainlessAliasMethodInfo = {
+    kind: 'alias_method_info';
+    httpMethod: HTTPMethod;
+    path: string;
+};
+export type StainlessWebhookUnwrapMethodInfo = {
+    kind: 'webhook_unwrap_method_info';
+};
+export type Parameter = (HasOASRef & HasStainlessPath) & {
+    kind: 'parameter';
+    key: string;
+    name: string;
+    location: string;
+    description?: string;
+    isRequired?: boolean;
+    isPositional: boolean;
+};
+export type Model = (HasOASRef & HasConfigRef & HasStainlessPath) & {
+    kind: 'model';
+    name: string;
+    title: string;
+    isImplicit: boolean;
+    stainlessPath: string;
+    configRef: string;
+    loading?: boolean;
+};
+export type BaseDeclaration = {
+    stainlessPath: string;
+    oasRef?: string;
+    configRef?: string;
+    loading?: boolean;
+    deprecated?: boolean | string;
+    snippet?: string;
+};
+export type BaseType = {
+    oasRef?: string;
+};
+export type Diagnostics = Record<string, DiagnosticExport[]>;
+export type Diagnostic = DiagnosticExport;
+export type LanguageDeclNodes = {
+    node: TSDeclaration;
+    typescript: TSDeclaration;
+    go: GoDeclaration;
+    python: PythonDeclaration;
+    terraform: TerraformDeclaration;
+    java: JavaDeclaration;
+    kotlin: JavaDeclaration;
+    ruby: RubyDeclaration;
+    http: HttpDeclaration;
+};
+export type ErrorDecl = BaseDeclaration & {
+    kind: 'ErrorDecl';
+    error: Error;
+    message: string;
+};
+export type DeclarationNode = LanguageDeclNodes[SpecLanguage];
+export declare function declare<T extends BaseDeclaration>(map: Map<string, T>, stainlessPath: string, generator: () => Omit<T, 'stainlessPath'>): ID;
+export declare function declareAll<T extends BaseDeclaration>(map: Map<string, T>, items: Array<{
+    stainlessPath: string;
+    generator: () => Omit<T, 'stainlessPath'>;
+}>): ID[];
+export declare function schemaChildrenParent(schema: SDKSchema): SDKSchemaType | undefined;
+export declare function processReadme(content: string, language: SupportedLanguage, languageSnippets: Record<string, any>): any;

package/dist/types/stainless-alias/lib/json-spec-v2/types.js

@@ -0,0 +1,105 @@
+import { getLogger } from '@pkg/logger';
+import * as GlobalSnippets from '~/templates/common/docs';
+import { ctx } from '~/templates/context';
+export const constraints = [
+    'minLength',
+    'maxLength',
+    'format',
+    'minimum',
+    'exclusiveMinimum',
+    'maximum',
+    'exclusiveMaximum',
+    'multipleOf',
+];
+export function constraintsFromSchema(rawSchema) {
+    const items = Object.entries(rawSchema).filter(([name]) => constraints.includes(name));
+    return items.length ? Object.fromEntries(items) : undefined;
+}
+export const SpecLanguages = [
+    'node',
+    'go',
+    'python',
+    'terraform',
+    'http',
+    'typescript',
+    'ruby',
+    'java',
+    'kotlin',
+];
+export function isSpecLanguage(language) {
+    return SpecLanguages.includes(language);
+}
+export const SnippetLanguages = [
+    'node.default',
+    'go.default',
+    'python.default',
+    'terraform.default',
+    'http.curl',
+    'http.powershell',
+    'typescript.default',
+    'ruby.default',
+    'java.default',
+    'kotlin.default',
+];
+/**
+ * Checks if thing is an Node.
+ * Not a sound check, it should only be called on values within an
+ * tree, and it only works because no node has a property
+ * of type Record<string, string>.
+ */
+export function isNode(thing) {
+    return typeof thing?.kind === 'string';
+}
+export function declare(map, stainlessPath, generator) {
+    if (map.has(stainlessPath)) {
+        return stainlessPath;
+    }
+    try {
+        const decl = generator();
+        decl.stainlessPath = stainlessPath;
+        map.set(stainlessPath, decl);
+        return stainlessPath;
+    }
+    catch (error) {
+        const errorDecl = {
+            kind: 'ErrorDecl',
+            stainlessPath,
+            error: error instanceof Error ? error : new Error(String(error)),
+            message: `Error generating declaration: ${error instanceof Error ? error.message : String(error)}`,
+        };
+        map.set(stainlessPath, errorDecl);
+        getLogger().error(`Error generating declaration for ${stainlessPath}:`, error);
+        return stainlessPath;
+    }
+}
+export function declareAll(map, items) {
+    if (items.length === 0) {
+        return [];
+    }
+    return items.map(({ stainlessPath, generator }) => declare(map, stainlessPath, generator));
+}
+// Populates the `childrenParentSchema` property on property declarations, used in the API Docs product
+// for e.g. determining if children are members of a union. This is a temporary hack and we should
+// instead have a richer intermediate metadata object that includes this and other data.
+export function schemaChildrenParent(schema) {
+    switch (schema.type) {
+        case 'array':
+        case 'map':
+            return schemaChildrenParent(schema.items.schema);
+        case 'object':
+        case 'intersection':
+        case 'union':
+        case 'enum':
+            return schema.type;
+        default:
+            return;
+    }
+}
+export function processReadme(content, language, languageSnippets) {
+    const snippets = {
+        ...languageSnippets,
+        ...GlobalSnippets,
+    };
+    return ctx.withLanguage(language, () => content.replace(/SDK_(\w+)/g, (_, key) => snippets[key]?.() ?? `SDK_${key}`));
+}
+//# sourceMappingURL=types.js.map

package/dist/types/stainless-alias/lib/json-spec-v2/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/types/stainless-alias/lib/json-spec-v2/types.ts"],"names":[],"mappings":"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"}

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import type { SDKJSON } from './types/sdkjson';
+export declare function flatResources(resources: Record<string, SDKJSON.Resource>, parents: SDKJSON.Resource[]): {
+    resource: SDKJSON.Resource;
+    parents: SDKJSON.Resource[];
+}[];
+export declare function getResourceFromSpec(stainlessPath: string | string[], spec: SDKJSON.Spec): SDKJSON.Resource | null;
+export declare function isResourceEmpty(resource: SDKJSON.Resource): boolean;

package/dist/utils.js

@@ -0,0 +1,27 @@
+import { parseStainlessPath } from './routing';
+export function flatResources(resources, parents) {
+    return Object.keys(resources)
+        .toSorted()
+        .flatMap((key) => {
+        const resource = resources[key];
+        return [
+            { resource, parents },
+            ...(resource.subresources ? flatResources(resource.subresources, [...parents, resource]) : []),
+        ];
+    });
+}
+export function getResourceFromSpec(stainlessPath, spec) {
+    if (typeof stainlessPath === 'string') {
+        const parsed = parseStainlessPath(stainlessPath);
+        if (!parsed?.resource)
+            return null;
+        stainlessPath = parsed.resource;
+    }
+    return stainlessPath.reduce((accum, cur, index) => (index === 0 ? accum?.[cur] : accum?.subresources?.[cur]), spec.resources);
+}
+export function isResourceEmpty(resource) {
+    return !(Object.values(resource.methods).length > 0 ||
+        Object.values(resource.models).length > 0 ||
+        Object.values(resource.subresources).length > 0);
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,UAAU,aAAa,CAC3B,SAA2C,EAC3C,OAA2B;IAE3B,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC;SAC1B,QAAQ,EAAE;SACV,OAAO,CAAC,CAAC,GAAoB,EAAE,EAAE;QAChC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAE,CAAC;QACjC,OAAO;YACL,EAAE,QAAQ,EAAE,OAAO,EAAE;YACrB,GAAG,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC,GAAG,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SAC/F,CAAC;IACJ,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,aAAgC,EAChC,IAAkB;IAElB,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,kBAAkB,CAAC,aAAa,CAAC,CAAC;QACjD,IAAI,CAAC,MAAM,EAAE,QAAQ;YAAE,OAAO,IAAI,CAAC;QACnC,aAAa,GAAG,MAAM,CAAC,QAAQ,CAAC;IAClC,CAAC;IAED,OAAO,aAAa,CAAC,MAAM,CACzB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,EAChF,IAAI,CAAC,SAAS,CACf,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,QAA0B;IACxD,OAAO,CAAC,CACN,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC;QAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,MAAM,GAAG,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,MAAM,GAAG,CAAC,CAChD,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@stainless-api/docs-ui",
-  "version": "0.1.0-beta.1",
+  "private": false,
+  "version": "0.1.0-beta.10",
   "publishConfig": {
     "access": "public"
   },
@@ -17,17 +18,17 @@
     "fuse.js": "^7.1.0",
     "htmlparser2": "^10.0.0",
     "lucide-react": "^0.544.0",
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1"
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "@stainless-api/ui-primitives": "0.1.0-beta.11"
   },
   "devDependencies": {
     "@types/node": "^24.4.0",
-    "@types/react": "^19.1.13",
-    "@types/react-dom": "^19.1.9",
-    "dotenv": "17.2.2",
+    "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.2",
+    "dotenv": "17.2.3",
     "esbuild": "^0.25.4",
     "tsx": "^4.20.3",
-    "@stainless-api/ui-primitives": "0.1.0-beta.1",
     "@stainless/eslint-config": "0.0.0"
   },
   "scripts": {

package/src/components/method.tsx

@@ -42,15 +42,17 @@ export function MethodIconBadge({ httpMethod, showName }: MethodIconProps) {
 
 export type MethodHeaderProps = {
   title: ReactNode;
+  level?: 'h1' | 'h2' | 'h3' | 'h4' | 'h5';
   signature?: ReactNode;
   badges?: ReactNode;
   children?: ReactNode;
 };
 
-export function MethodHeader({ title, badges, signature, children }: MethodHeaderProps) {
+export function MethodHeader({ title, badges, signature, children, level }: MethodHeaderProps) {
+  const Heading = level ?? 'h5';
   return (
     <div className={style.MethodHeader}>
-      <h5 className={style.MethodTitle}>{title}</h5>
+      <Heading className={style.MethodTitle}>{title}</Heading>
       {badges && <div className={style.MethodBadges}>{badges}</div>}
       {signature}
       {children}

package/src/components/overview.tsx

@@ -58,6 +58,7 @@ export function SDKMethodSummary({ method }: SDKMethodSummaryProps) {
 
   return (
     <Docs.MethodHeader
+      level="h5"
       title={<Docs.Link stainlessPath={method.stainlessPath}>{method.summary ?? method.title}</Docs.Link>}
       signature={<Lang.MethodSignature decl={decl} />}
       badges={method.deprecated && <Docs.Badge id="deprecated">Deprecated</Docs.Badge>}

package/src/components/sdk.tsx

@@ -243,6 +243,7 @@ export function SDKMethodHeader({ method }: SDKMethodProps) {
 
   return (
     <Docs.MethodHeader
+      level="h1"
       title={method.summary ?? method.title}
       signature={<Lang.MethodSignature decl={decl} />}
       badges={method.deprecated && <Docs.Badge id="deprecated">Deprecated</Docs.Badge>}
@@ -383,9 +384,9 @@ export function SDKLanguageBlock({ language, version, install, links }: SDKLangu
 
       <div className={style.LanguageBlockInstall} data-stldocs-copy-parent>
         <pre data-stldocs-copy-content>{install}</pre>{' '}
-        <button data-stldocs-snippet-copy>
+        <Button variant="ghost" size="sm" data-stldocs-snippet-copy>
           <Copy size={16} className={style.Icon} />
-        </button>
+        </Button>
       </div>
 
       <div className={style.LanguageBlockLinks}>