@stainless-api/docs-search 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/types-O3Jwo7Us.d.ts

@@ -0,0 +1,1604 @@
+import { DocsLanguage } from "@stainless-api/docs-ui/routing";
+import { Code } from "@pkg/plada/src/core";
+
+//#region ../sdk-json/index.d.ts
+declare type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
+interface BaseOperation {
+  path: string;
+}
+interface AddOperation<T> extends BaseOperation {
+  op: 'add';
+  value: T;
+}
+interface RemoveOperation extends BaseOperation {
+  op: 'remove';
+}
+interface ReplaceOperation<T> extends BaseOperation {
+  op: 'replace';
+  value: T;
+}
+interface MoveOperation extends BaseOperation {
+  op: 'move';
+  from: string;
+}
+interface CopyOperation extends BaseOperation {
+  op: 'copy';
+  from: string;
+}
+interface TestOperation<T> extends BaseOperation {
+  op: 'test';
+  value: T;
+}
+interface GetOperation<T> extends BaseOperation {
+  op: '_get';
+  value: T;
+}
+type Primitive$2 = null | undefined | string | number | boolean | symbol | bigint;
+type BuiltIns = Primitive$2 | void | Date | RegExp;
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<Type, ExcludeType | NonRecursiveType | Set<unknown> | Map<unknown, unknown>, object>;
+type ConditionalSimplifyDeep<Type, ExcludeType = never, IncludeType = unknown> = Type extends ExcludeType ? Type : Type extends IncludeType ? { [TypeKey in keyof Type]: ConditionalSimplifyDeep<Type[TypeKey], ExcludeType, IncludeType> } : Type;
+type HeaderObject = ParameterBaseObject;
+type ParameterBaseObject = {
+  description?: string;
+  required?: boolean;
+  deprecated?: boolean;
+  allowEmptyValue?: boolean;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+  schema?: SchemaObject;
+  example?: unknown;
+  examples?: {
+    [media: string]: ExampleObject;
+  };
+  content?: {
+    [media: string]: MediaTypeObject;
+  };
+};
+type PropertiesObject = {
+  [name: string]: SchemaObject;
+};
+type SchemaListObject = Array< /* ReferenceObject | */SchemaObject>;
+type SchemaPrimitiveType = 'null' | 'boolean' | 'number' | 'string' | 'integer';
+type NonArraySchemaObjectType = SchemaPrimitiveType | 'object' | 'binary-response' | 'unknown';
+type SchemaObjectType = NonArraySchemaObjectType | 'array';
+interface SchemaObject {
+  type?: SchemaObjectType | Array<SchemaObjectType>;
+  title?: string;
+  description?: string;
+  format?: string;
+  default?: any;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: boolean | number;
+  minimum?: number;
+  exclusiveMinimum?: boolean | number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  additionalProperties?: boolean | /* ReferenceObject | */SchemaObject;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  enum?: unknown[];
+  const?: any;
+  properties?: PropertiesObject;
+  allOf?: SchemaListObject;
+  anyOf?: SchemaListObject;
+  oneOf?: SchemaListObject;
+  items?: SchemaObject;
+  nullable?: boolean;
+  discriminator?: DiscriminatorObject;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  example?: any;
+  examples?: any[];
+  deprecated?: boolean;
+  $ref?: string;
+  [key: `x-${string}`]: unknown;
+  [key: `_x-${string}`]: unknown;
+}
+type DiscriminatorObject = {
+  propertyName: string;
+  mapping?: {
+    [value: string]: string;
+  };
+};
+type ExampleObject = {
+  summary?: string;
+  description?: string;
+  value?: unknown;
+  externalValue?: string;
+};
+type EncodingsObject = {
+  [media: string]: EncodingObject;
+};
+interface MediaTypeObject {
+  schema?: SchemaObject;
+  nullable?: boolean;
+  example?: any;
+  examples?: {
+    [media: string]: ExampleObject;
+  };
+  encoding?: EncodingsObject;
+}
+type EncodingObject = {
+  contentType?: string;
+  headers?: HeadersObject;
+  style?: string;
+  explode?: boolean;
+  allowReserved?: boolean;
+};
+type ResponseContentObject = {
+  [media: string]: MediaTypeObject;
+};
+type HeadersObject = {
+  [key: string]: HeaderObject;
+};
+type SupportedLanguage = 'node' | 'typescript' | 'python' | 'go' | 'java' | 'kotlin' | 'ruby' | 'terraform' | 'cli' | 'php' | 'csharp' | 'sql' | 'http' | 'openapi';
+interface Config {
+  docs: {
+    title?: string | undefined;
+    favicon?: string | undefined;
+    logo_icon?: string | undefined;
+    search?: {
+      algolia?: {
+        app_id: string;
+        index_name: string;
+        search_key: string;
+      } | undefined;
+    } | undefined;
+    description?: string | undefined;
+    languages?: SupportedLanguage[] | undefined;
+    snippets?: {
+      exclude_languages?: string[] | undefined;
+    } | undefined;
+    show_security?: boolean | undefined;
+    show_readme?: boolean | undefined;
+    base_path?: string | undefined;
+    navigation?: unknown;
+    pages?: Record<string, string> | undefined;
+    resources?: {
+      title: string;
+      children: string[];
+    }[] | undefined;
+  } | undefined;
+}
+type InternalDiagnosticLevel = 'fatal' | 'internal_error' | 'error' | 'warning' | 'note';
+type DiagnosticLevel = Exclude<InternalDiagnosticLevel, 'internal_error'>;
+type AutoFixOp = SimplifyDeep<{
+  file: 'config';
+} & Operation>;
+type DiagnosticInfo = {
+  code: string;
+  level: InternalDiagnosticLevel;
+  ignored: boolean;
+  message: string;
+  messageHtml: string;
+  more: string | {
+    raw: string;
+  } | null;
+  link: string;
+  endpoint: string | null;
+  language: SupportedLanguage | null;
+  customer: string | null;
+  location: string | null;
+  stainlessPath: string | null;
+  oasRef: string | null;
+  configRef: string | null;
+  autoFixPlan: AutoFixOp[] | null;
+  trace?: string;
+};
+type DiagnosticExport = DiagnosticInfo & {
+  level: DiagnosticLevel;
+};
+type SDKSchemaReference = never;
+type SDKSchemaType = string;
+type SDKPropertySchemaReference<T = never> = never;
+type HttpDeclaration = HttpDeclFunction | HttpDeclProperty | HttpDeclTypeAlias | HttpDeclReference | ErrorDecl;
+type HttpDeclFunction = BaseDeclaration & {
+  kind: 'HttpDeclFunction';
+  ident: HttpIdentifier;
+  qualified?: string;
+  returns?: HttpType;
+  paramsChildren?: Record<string, ID[]>;
+  bodyParamsChildren?: Record<string, ID[]>;
+  responseChildren?: ID[];
+};
+type HttpDeclProperty = BaseDeclaration & {
+  kind: 'HttpDeclProperty';
+  key: string;
+  docstring?: string;
+  title?: string;
+  location?: string;
+  type: HttpType;
+  constraints?: Constraints;
+  default?: unknown;
+  examples?: unknown[];
+  optional?: boolean;
+  nullable?: boolean;
+  declare?: boolean;
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type HttpDeclTypeAlias = BaseDeclaration & {
+  kind: 'HttpDeclTypeAlias';
+  docstring?: string;
+  ident: HttpIdentifier;
+  typeParameters?: HttpTypeParameter[];
+  type: HttpType;
+  children?: ID[];
+};
+type HttpTypeParameter = {
+  kind: 'HttpTypeParameter';
+  name: HttpIdentifier;
+  constraint?: HttpType;
+  default?: HttpType;
+};
+type HttpIdentifier = string;
+type HttpDeclReference = BaseDeclaration & {
+  kind: 'HttpDeclReference';
+  docstring?: string;
+  type: HttpType;
+  children?: ID[];
+};
+type HttpType = HttpTypeReference | HttpTypeObject | HttpTypeArray | HttpTypeString | HttpTypeNumber | HttpTypeBoolean | HttpTypeNull | HttpTypeUndefined | HttpTypeBinary | HttpTypeUnknown | HttpTypeLiteral | HttpTypeUnion | HttpTypeIntersection;
+type HttpTypeReference = BaseType & {
+  kind: 'HttpTypeReference';
+  ident: HttpIdentifier;
+  typeParameters?: HttpType[];
+  $ref?: ID;
+};
+type HttpTypeObject = BaseType & {
+  kind: 'HttpTypeObject';
+  members: {
+    ident: HttpIdentifier;
+    optional?: boolean;
+  }[];
+};
+type HttpTypeArray = BaseType & {
+  kind: 'HttpTypeArray';
+  elementType: HttpType;
+};
+type HttpTypeUnion = BaseType & {
+  kind: 'HttpTypeUnion';
+  types: HttpType[];
+};
+type HttpTypeIntersection = BaseType & {
+  kind: 'HttpTypeIntersection';
+  types: HttpType[];
+};
+type HttpTypeLiteral = BaseType & {
+  kind: 'HttpTypeLiteral';
+  literal: string | boolean | number;
+};
+type HttpTypeString = BaseType & {
+  kind: 'HttpTypeString';
+};
+type HttpTypeNumber = BaseType & {
+  kind: 'HttpTypeNumber';
+};
+type HttpTypeBoolean = BaseType & {
+  kind: 'HttpTypeBoolean';
+};
+type HttpTypeNull = BaseType & {
+  kind: 'HttpTypeNull';
+};
+type HttpTypeUndefined = BaseType & {
+  kind: 'HttpTypeUndefined';
+};
+type HttpTypeBinary = BaseType & {
+  kind: 'HttpTypeBinary';
+  contentType: string[];
+};
+type HttpTypeUnknown = BaseType & {
+  kind: 'HttpTypeUnknown';
+};
+/**
+ * Base declaration types for CLI command AST
+ */
+type CLIDeclaration = CLICommand | CLIFlag | CLISchemaProperty | CLIStdin | CLIFunction | ErrorDecl;
+/**
+ * Represents a command in a CLI environment
+ */
+type CLICommand = BaseDeclaration & {
+  kind: 'CLICommand';
+  invocation: string[];
+  name: string;
+  arguments?: CLIArgument[];
+  options?: CLIFlag[];
+  stdin?: CLIStdin;
+  background?: boolean;
+  subshell?: boolean;
+  workingDir?: string;
+  children?: ID[];
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+  ident: string;
+  qualified?: string;
+  docstring?: string;
+  parameters?: unknown[];
+  responseType?: HttpType;
+};
+/**
+ * Represents a command argument
+ */
+type CLIArgument = {
+  kind: 'CLIArgument';
+  value: string;
+  quoted?: boolean;
+  docstring?: string;
+  quoteType?: 'single' | 'double' | 'backtick';
+};
+/**
+ * Represents a command line flag --foo
+ */
+type CLIFlag = BaseDeclaration & {
+  kind: 'CLIFlag';
+  name?: string;
+  enabled?: boolean;
+  ident: string;
+  flag?: string | {
+    name: string;
+  };
+  title?: string;
+  docstring?: string;
+  optional?: boolean;
+  type?: HttpType;
+  constraints?: unknown;
+  schemaType?: string;
+  modelPath?: string;
+  childrenParentSchema?: unknown;
+  children?: ID[];
+};
+/**
+ * Represents a CLI property (for return values/response fields)
+ */
+type CLISchemaProperty = BaseDeclaration & {
+  kind: 'CLISchemaProperty';
+  name: string;
+  ident: string;
+  type?: HttpType;
+  docstring?: string;
+  optional?: boolean;
+  constraints?: unknown;
+  schemaType?: string;
+  children?: ID[];
+  childrenParentSchema?: unknown;
+};
+/**
+ * Represents data piped in to stdin
+ */
+type CLIStdin = BaseDeclaration & {
+  kind: 'CLIStdin';
+  text: string;
+};
+/**
+ * Represents a shell function
+ */
+type CLIFunction = BaseDeclaration & {
+  kind: 'CLIFunction';
+  name: string;
+  body: CLICommand[];
+  parameters?: string[];
+  description?: string;
+  docstring?: string;
+  children?: ID[];
+};
+type CSharpDeclaration = CSharpDeclFunction | CSharpDeclType | CSharpDeclProperty | CSharpDeclConst | CSharpDeclReference | ErrorDecl;
+type CSharpDeclFunction = BaseDeclaration & {
+  kind: 'CSharpDeclFunction';
+  ident: CSharpIdentifier;
+  qualified?: string;
+  docstring?: string;
+  async?: boolean;
+  parameters: CSharpFunctionParameter[];
+  returnType?: CSharpType;
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type CSharpFunctionParameter = {
+  kind: 'CSharpFunctionParameter';
+  ident: CSharpIdentifier;
+  typeAnnotation: CSharpType;
+  hasDefault: boolean;
+};
+type CSharpDeclType = BaseDeclaration & {
+  kind: 'CSharpDeclType';
+  docstring?: string;
+  ident: CSharpIdentifier;
+  type: CSharpType;
+  children?: ID[];
+};
+type CSharpIdentifier = string;
+type CSharpDeclProperty = BaseDeclaration & {
+  kind: 'CSharpDeclProperty';
+  docstring?: string;
+  title?: string;
+  ident: CSharpIdentifier;
+  type: CSharpType;
+  optional?: boolean;
+  nullable?: boolean;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type CSharpDeclConst = BaseDeclaration & {
+  kind: 'CSharpDeclConst';
+  docstring?: string;
+  ident: CSharpIdentifier;
+  type: CSharpType;
+  value: boolean | string | number;
+};
+type CSharpDeclReference = BaseDeclaration & {
+  kind: 'CSharpDeclReference';
+  docstring?: string;
+  type: CSharpType;
+  schemaType?: SchemaType;
+  children?: ID[];
+};
+type CSharpType = CSharpTypeReference | CSharpTypeClass | CSharpTypeUnion | CSharpTypeEnum | CSharpTypeBoolean | CSharpTypeFloat | CSharpTypeDouble | CSharpTypeInt | CSharpTypeLong | CSharpTypeString | CSharpTypeConstant;
+type CSharpTypeReference = BaseType & {
+  kind: 'CSharpTypeReference';
+  typeName: CSharpIdentifier;
+  typeParameters?: CSharpType[];
+  nullable?: boolean;
+  $ref?: string;
+};
+type CSharpTypeClass = BaseType & {
+  kind: 'CSharpTypeClass';
+};
+type CSharpTypeUnion = BaseType & {
+  kind: 'CSharpTypeUnion';
+};
+type CSharpTypeEnum = BaseType & {
+  kind: 'CSharpTypeEnum';
+};
+type CSharpTypeBoolean = BaseType & {
+  kind: 'CSharpTypeBoolean';
+};
+type CSharpTypeFloat = BaseType & {
+  kind: 'CSharpTypeFloat';
+};
+type CSharpTypeDouble = BaseType & {
+  kind: 'CSharpTypeDouble';
+};
+type CSharpTypeInt = BaseType & {
+  kind: 'CSharpTypeInt';
+};
+type CSharpTypeLong = BaseType & {
+  kind: 'CSharpTypeLong';
+};
+type CSharpTypeString = BaseType & {
+  kind: 'CSharpTypeString';
+};
+type CSharpTypeConstant = BaseType & {
+  kind: 'CSharpTypeConstant';
+  value: string;
+};
+type JavaDeclaration = JavaDeclFunction | JavaDeclType | JavaDeclProperty | JavaDeclConst | JavaDeclReference | ErrorDecl;
+type JavaDeclFunction = BaseDeclaration & {
+  kind: 'JavaDeclFunction';
+  ident: JavaIdentifier;
+  qualified?: string;
+  docstring?: string;
+  async?: boolean;
+  parameters: JavaFunctionParameter[];
+  returnType?: JavaType;
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type JavaFunctionParameter = {
+  kind: 'JavaFunctionParameter';
+  ident: JavaIdentifier;
+  typeAnnotation: JavaType;
+  hasDefault: boolean;
+};
+type JavaDeclType = BaseDeclaration & {
+  kind: 'JavaDeclType';
+  docstring?: string;
+  ident: JavaIdentifier;
+  type: JavaType;
+  children?: ID[];
+};
+type JavaIdentifier = string;
+type JavaDeclProperty = BaseDeclaration & {
+  kind: 'JavaDeclProperty';
+  docstring?: string;
+  title?: string;
+  ident: JavaIdentifier;
+  type: JavaType;
+  optional?: boolean;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type JavaDeclConst = BaseDeclaration & {
+  kind: 'JavaDeclConst';
+  docstring?: string;
+  ident: JavaIdentifier;
+  type: JavaType;
+  value: boolean | string | number;
+};
+type JavaDeclReference = BaseDeclaration & {
+  kind: 'JavaDeclReference';
+  docstring?: string;
+  type: JavaType;
+  schemaType?: SchemaType;
+  children?: ID[];
+};
+type JavaType = JavaTypeReference | JavaTypeClass | JavaTypeUnion | JavaTypeEnum | JavaTypeVoid | JavaTypeBoolean | JavaTypeDouble | JavaTypeLong | JavaTypeString | JavaTypeConstant;
+type JavaTypeReference = BaseType & {
+  kind: 'JavaTypeReference';
+  typeName: JavaIdentifier;
+  typeParameters?: JavaType[];
+  $ref?: string;
+};
+type JavaTypeClass = BaseType & {
+  kind: 'JavaTypeClass';
+};
+type JavaTypeUnion = BaseType & {
+  kind: 'JavaTypeUnion';
+};
+type JavaTypeEnum = BaseType & {
+  kind: 'JavaTypeEnum';
+};
+type JavaTypeVoid = BaseType & {
+  kind: 'JavaTypeVoid';
+};
+type JavaTypeBoolean = BaseType & {
+  kind: 'JavaTypeBoolean';
+};
+type JavaTypeDouble = BaseType & {
+  kind: 'JavaTypeDouble';
+};
+type JavaTypeLong = BaseType & {
+  kind: 'JavaTypeLong';
+};
+type JavaTypeString = BaseType & {
+  kind: 'JavaTypeString';
+};
+type JavaTypeConstant = BaseType & {
+  kind: 'JavaTypeConstant';
+  value: string;
+};
+type PhpIdentifier = string;
+type PhpDeclaration = PhpDeclMethod | PhpDeclParam | PhpDeclClass | PhpDeclClassProperty | PhpDeclAssocArray | PhpDeclAssocArrayProperty | PhpDeclEnum | PhpDeclReference | ErrorDecl;
+type PhpDeclMethod = BaseDeclaration & {
+  kind: 'PhpDeclMethod';
+  ident: PhpIdentifier;
+  parameters: PhpMethodParameter[];
+  returnType?: PhpType;
+  qualified?: string;
+  docstring?: string;
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type PhpMethodParameter = {
+  kind: 'PhpMethodParameter';
+  ident: PhpIdentifier;
+  typeAnnotation: PhpType;
+  optional: boolean;
+  hasDefault?: boolean;
+};
+type PhpDeclReference = BaseDeclaration & {
+  kind: 'PhpDeclReference';
+  docstring?: string;
+  type: PhpType;
+  scope?: 'class' | '@phpstan-type';
+  children?: ID[];
+};
+type PhpDeclParam = BaseDeclaration & {
+  kind: 'PhpDeclParam';
+  ident: PhpIdentifier;
+  type: PhpType;
+  optional: boolean;
+  isPositional: boolean;
+  default?: unknown;
+  examples?: unknown[];
+  oasRef?: string;
+  modelPath?: string;
+  docstring?: string;
+  deprecated?: string | boolean;
+  children?: ID[];
+};
+/** For PHPStan array definitions. */
+type PhpDeclAssocArrayProperty = BaseDeclaration & {
+  kind: 'PhpDeclAssocArrayProperty';
+  ident: PhpIdentifier;
+  type: PhpType;
+  optional: boolean;
+  oasRef?: string;
+  modelPath?: string;
+  docstring?: string;
+  deprecated?: string | boolean;
+  children?: ID[];
+};
+type PhpDeclClassProperty = BaseDeclaration & {
+  kind: 'PhpDeclClassProperty';
+  ident: PhpIdentifier;
+  type: PhpType;
+  nullable: boolean;
+  docstring?: string;
+  default?: string;
+  examples?: unknown[];
+  deprecated?: string | boolean;
+  modelPath?: string;
+  children?: ID[];
+};
+type PhpDeclEnum = BaseDeclaration & {
+  kind: 'PhpDeclEnum';
+  ident: PhpIdentifier;
+  members: {
+    case: PhpIdentifier;
+    backingType?: 'string' | 'int';
+    value?: string | number;
+  }[];
+};
+type PhpDeclClass = BaseDeclaration & {
+  kind: 'PhpDeclClass';
+  ident: PhpIdentifier;
+  docstring?: string;
+  children?: ID[];
+};
+type PhpDeclAssocArray = BaseDeclaration & {
+  kind: 'PhpDeclAssocArray';
+  ident: PhpIdentifier;
+  type: PhpType;
+  children?: ID[];
+};
+type PhpType = SDKJSONPhpType<string>;
+type SDKJSONPhpIdentifier<T extends Code = string> = T;
+type SDKJSONPhpType<T extends Code = string> = PhpTypeReference<T> | PhpTypeMapArray<T> | PhpTypeListArray<T> | PhpTypeUnion<T> | PhpTypeLiteral | PhpTypeString | PhpTypeFloat | PhpTypeInt | PhpTypeBool | PhpTypeNull | PhpTypeMixed | PhpTypeDatetime | PhpTypeComplexBuiltin;
+type PhpTypeReference<T extends Code = string> = BaseType & {
+  kind: 'PhpTypeReference';
+  typeName: SDKJSONPhpIdentifier<T>;
+  $ref?: ID | string;
+  typeParameters?: PhpType[];
+};
+type PhpTypeMapArray<T extends Code = string> = BaseType & {
+  kind: 'PhpTypeMapArray';
+  elementType: SDKJSONPhpType<T>;
+};
+type PhpTypeListArray<T extends Code = string> = BaseType & {
+  kind: 'PhpTypeListArray';
+  elementType: SDKJSONPhpType<T>;
+};
+type PhpTypeUnion<T extends Code = string> = BaseType & {
+  kind: 'PhpTypeUnion';
+  types: SDKJSONPhpType<T>[];
+};
+type PhpTypeLiteral = BaseType & {
+  kind: 'PhpTypeLiteral';
+  literal: string | boolean | number;
+};
+type PhpTypeString = BaseType & {
+  kind: 'PhpTypeString';
+};
+type PhpTypeFloat = BaseType & {
+  kind: 'PhpTypeFloat';
+};
+type PhpTypeInt = BaseType & {
+  kind: 'PhpTypeInt';
+};
+type PhpTypeBool = BaseType & {
+  kind: 'PhpTypeBool';
+};
+type PhpTypeNull = BaseType & {
+  kind: 'PhpTypeNull';
+};
+type PhpTypeMixed = BaseType & {
+  kind: 'PhpTypeMixed';
+};
+type PhpTypeDatetime = BaseType & {
+  kind: 'PhpTypeDatetime';
+};
+type PhpTypeComplexBuiltin = BaseType & {
+  kind: 'PhpTypeComplexBuiltin';
+  typeName: 'resource' | 'callable' | 'class-string' | 'array' | 'object';
+};
+type PythonDeclaration = PythonDeclFunction | PythonDeclClass | PythonDeclType | PythonDeclProperty | PythonDeclReference | ErrorDecl;
+type PythonDeclFunction = BaseDeclaration & {
+  kind: 'PythonDeclFunction';
+  ident: PythonIdentifier;
+  qualified?: string;
+  docstring?: string;
+  async?: boolean;
+  generics?: PythonGenericParameter[];
+  parameters: PythonFunctionParameter[];
+  returns?: PythonType;
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type PythonFunctionParameter = {
+  kind: 'PythonFunctionParameter';
+  ident: PythonIdentifier;
+  type: PythonType;
+  optional?: boolean;
+};
+type PythonGenericParameter = {
+  kind: 'PythonTypeParameter';
+  name: string;
+  constraint?: PythonType;
+};
+type PythonDeclClass = BaseDeclaration & {
+  kind: 'PythonDeclClass';
+  docstring?: string;
+  ident: PythonIdentifier;
+  generics?: PythonGenericParameter[];
+  children?: ID[];
+};
+type PythonDeclType = BaseDeclaration & {
+  kind: 'PythonDeclType';
+  docstring?: string;
+  ident: PythonIdentifier;
+  generics?: PythonGenericParameter[];
+  type: PythonType;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type PythonIdentifier = string;
+type PythonLiteral = {
+  kind: 'PythonLiteral';
+  value: string | number | boolean;
+};
+type PythonDeclProperty = BaseDeclaration & {
+  kind: 'PythonDeclProperty';
+  docstring?: string;
+  title?: string;
+  ident: PythonIdentifier;
+  type: PythonType;
+  constraints?: Constraints;
+  optional?: boolean;
+  default?: unknown;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type PythonDeclReference = BaseDeclaration & {
+  kind: 'PythonDeclReference';
+  docstring?: string;
+  type: PythonType;
+  children?: ID[];
+};
+type PythonType = PythonTypeReference | PythonTypeClass | PythonTypeArray | PythonTypeMap | PythonTypeString | PythonTypeFloat | PythonTypeInt | PythonTypeBool | PythonTypeAny | PythonTypeUnknown | PythonTypeLiteral;
+type PythonTypeReference = BaseType & {
+  kind: 'PythonTypeReference';
+  typeName: PythonIdentifier;
+  typeParameters?: PythonType[];
+  schemaType?: SchemaType;
+  $ref?: string;
+};
+type PythonTypeClass = BaseType & {
+  kind: 'PythonTypeClass';
+  body: {
+    ident: PythonIdentifier;
+    type: PythonType;
+  }[];
+};
+type PythonTypeArray = BaseType & {
+  kind: 'PythonTypeArray';
+  elementType: PythonType;
+};
+type PythonTypeMap = BaseType & {
+  kind: 'PythonTypeMap';
+  indexType: PythonType;
+  itemType: PythonType;
+};
+type PythonTypeString = BaseType & {
+  kind: 'PythonTypeString';
+};
+type PythonTypeFloat = BaseType & {
+  kind: 'PythonTypeFloat';
+};
+type PythonTypeInt = BaseType & {
+  kind: 'PythonTypeInt';
+};
+type PythonTypeBool = BaseType & {
+  kind: 'PythonTypeBool';
+};
+type PythonTypeAny = BaseType & {
+  kind: 'PythonTypeAny';
+};
+type PythonTypeUnknown = BaseType & {
+  kind: 'PythonTypeUnknown';
+};
+type PythonTypeLiteral = BaseType & {
+  kind: 'PythonTypeLiteral';
+  literal: PythonLiteral;
+};
+type RubyDeclaration = RubyDeclFunction | RubyDeclClass | RubyDeclProperty | RubyDeclTypeAlias | RubyDeclReference | ErrorDecl;
+type RubyDeclFunction = BaseDeclaration & {
+  kind: 'RubyDeclFunction';
+  ident: RubyIdentifier;
+  args: RubyFunctionArgument[];
+  qualified?: string;
+  returns?: RubyType;
+  paramsChildren?: ID[];
+  bodyParamsChildren?: Record<string, ID[]>;
+  responseChildren?: ID[];
+};
+type RubyFunctionArgument = {
+  kind: 'RubyFunctionArgument';
+  ident: RubyIdentifier;
+  optional: boolean;
+  type: RubyType;
+};
+type RubyDeclProperty = BaseDeclaration & {
+  kind: 'RubyDeclProperty';
+  ident: string;
+  docstring?: string;
+  title?: string;
+  location?: string;
+  type: RubyType;
+  constraints?: Constraints;
+  optional?: boolean;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type RubyDeclClass = BaseDeclaration & {
+  kind: 'RubyDeclClass';
+  ident: string;
+  docstring?: string;
+  type: RubyType;
+  optional?: boolean;
+  children?: ID[];
+};
+type RubyDeclTypeAlias = BaseDeclaration & {
+  kind: 'RubyDeclTypeAlias';
+  docstring?: string;
+  ident: RubyIdentifier;
+  typeParameters?: RubyTypeParameter[];
+  type: RubyType;
+  children?: ID[];
+};
+type RubyTypeParameter = {
+  kind: 'RubyTypeParameter';
+  name: RubyIdentifier;
+  constraint?: RubyType;
+  default?: RubyType;
+};
+type RubyIdentifier = string;
+type RubyDeclReference = BaseDeclaration & {
+  kind: 'RubyDeclReference';
+  docstring?: string;
+  type: RubyType;
+  children?: ID[];
+};
+type RubyType = RubyTypeReference | RubyTypeObject | RubyTypeArray | RubyTypeMap | RubyTypeString | RubyTypeInteger | RubyTypeFloat | RubyTypeBoolean | RubyTypeNull | RubyTypeBinary | RubyTypeUnknown | RubyTypeLiteral | RubyTypeUnion | RubyTypeIntersection | RubyTypeBuiltinClass;
+type RubyTypeReference = BaseType & {
+  kind: 'RubyTypeReference';
+  ident: RubyIdentifier;
+  typeParameters?: RubyType[];
+  schemaType?: SchemaType;
+  $ref?: ID;
+};
+type RubyTypeObject = BaseType & {
+  kind: 'RubyTypeObject';
+  members: {
+    ident: RubyIdentifier;
+    optional?: boolean;
+  }[];
+};
+type RubyTypeMap = BaseType & {
+  kind: 'RubyTypeMap';
+  indexType: RubyType;
+  itemType: RubyType;
+};
+type RubyTypeArray = BaseType & {
+  kind: 'RubyTypeArray';
+  elementType: RubyType;
+};
+type RubyTypeUnion = BaseType & {
+  kind: 'RubyTypeUnion';
+  types: RubyType[];
+};
+type RubyTypeIntersection = BaseType & {
+  kind: 'RubyTypeIntersection';
+  types: RubyType[];
+};
+type RubyTypeLiteral = BaseType & {
+  kind: 'RubyTypeLiteral';
+  literal: string | boolean | number;
+};
+type RubyTypeBuiltinClass = BaseType & {
+  kind: 'RubyTypeBuiltinClass';
+  className: string;
+};
+type RubyTypeString = BaseType & {
+  kind: 'RubyTypeString';
+};
+type RubyTypeInteger = BaseType & {
+  kind: 'RubyTypeInteger';
+};
+type RubyTypeFloat = BaseType & {
+  kind: 'RubyTypeFloat';
+};
+type RubyTypeBoolean = BaseType & {
+  kind: 'RubyTypeBoolean';
+};
+type RubyTypeNull = BaseType & {
+  kind: 'RubyTypeNull';
+};
+type RubyTypeBinary = BaseType & {
+  kind: 'RubyTypeBinary';
+  contentType: string[];
+};
+type RubyTypeUnknown = BaseType & {
+  kind: 'RubyTypeUnknown';
+};
+type PrimitiveNumberProps$1 = {
+  oneof?: (number | bigint)[];
+  default: number | bigint | null;
+  minimum: number | bigint | null;
+  maximum: number | bigint | null;
+};
+type Primitive$1 = {
+  category: 'primitive';
+  schemaRef?: SDKSchemaReference;
+} & ({
+  type: 'Bool';
+  default: boolean | null;
+} | ({
+  type: 'Float64';
+} & PrimitiveNumberProps$1) | ({
+  type: 'Int64';
+} & PrimitiveNumberProps$1) | ({
+  type: 'Number';
+} & PrimitiveNumberProps$1) | {
+  type: 'Time';
+  default: string | null;
+} | {
+  type: 'String';
+  oneof?: string[];
+  default: string | null;
+});
+type Dynamic$1 = {
+  category: 'dynamic';
+  type: 'Dynamic';
+  schemaRef?: SDKSchemaReference;
+  allowedSubtypes: Primitive$1['type'][];
+};
+type Unknown$1 = {
+  category: 'unknown';
+  type: 'unknown';
+  schemaRef?: SDKSchemaReference;
+};
+type Collection$1 = {
+  category: 'collection';
+  type: 'List' | 'Map' | 'Set';
+  elementType: AttributeType$1;
+  schemaRef?: SDKSchemaReference;
+};
+type Nested$1 = {
+  category: 'nested';
+  type: 'ListNested' | 'MapNested' | 'SetNested' | 'SingleNested';
+  attributes: TerraformAttribute[];
+  schemaRef?: SDKSchemaReference;
+  modelTypeName: string;
+  validators: TerraformValidators;
+};
+type AttributeType$1 = Nested$1 | Collection$1 | Dynamic$1 | Primitive$1 | Unknown$1;
+/**
+ * required: The value must be practitioner configured to an eventually known value (not null),
+ *   otherwise the framework will automatically raise an error diagnostic for the missing value.
+ *
+ * optional: The value may be practitioner configured to a known value or null.
+ *
+ * computed: The value will be set in provider logic and any practitioner configuration causes
+ *   the framework to automatically raise an error diagnostic for the unexpected configuration value.
+ *
+ * computed_optional: The value may be practitioner configured or the value may be set in
+ *   provider logic when the practitioner configuration is null.
+ */
+type Configurability = 'required' | 'optional' | 'computed' | 'computed_optional';
+type TerraformSchemaType = 'resource' | 'provider' | 'datasource';
+type PathExpr$1 = Readonly<{
+  path: string;
+  container?: Collection$1['type'] | Nested$1['type'];
+}>;
+type PathExpression$1 = readonly PathExpr$1[];
+type TerraformAttribute = {
+  name: string;
+  description?: string;
+  configurability: Configurability;
+  configurabilityOverride: boolean;
+  property?: SDKPropertySchemaReference;
+  type: AttributeType$1;
+  idProperty?: boolean;
+  requiresReplace?: boolean;
+  sensitive?: boolean;
+  deprecated?: string | boolean;
+  noRefresh?: boolean;
+  isBodyRootParam?: boolean;
+  syntheticType?: 'id' | 'find-by' | 'max-items' | 'items' | 'timeout';
+  schemaType: TerraformSchemaType;
+  pathExpr: PathExpression$1; /** whether this attribute is immediately nested inside a computed (or computed_optional) collection/object */
+  nestedInComputedAttribute?: boolean;
+};
+declare const TerraformPathValidations: readonly ['requiredTogether', 'atLeastOneOf', 'exactlyOneOf', 'conflicting'];
+type PathValidators = Record<(typeof TerraformPathValidations)[number], PathExpression$1[][]>;
+type TerraformValidators = {
+  path: PathValidators;
+  any: never[];
+  all: never[];
+};
+type TerraformDeclaration = TerraformDeclServiceNode | TerraformDeclSource | TerraformDeclAttribute | ErrorDecl;
+type TerraformDeclServiceNode = BaseDeclaration & {
+  kind: 'TerraformDeclServiceNode';
+  resource?: ID;
+  dataSource?: ID;
+  listDataSource?: ID;
+};
+type TerraformDeclSource = BaseDeclaration & {
+  kind: 'TerraformDeclSource';
+  name: string;
+  type: 'resource' | 'datasource-plural' | 'datasource-single';
+  methodName: string;
+  required: ID[];
+  optional: ID[];
+  computed: ID[];
+};
+type PrimitiveNumberProps = {
+  oneof?: number[];
+  default: number | null;
+  minimum: number | null;
+  maximum: number | null;
+};
+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;
+});
+type Dynamic = {
+  category: 'dynamic';
+  type: 'Dynamic';
+  allowedSubtypes: Primitive['type'][];
+};
+type Unknown = {
+  category: 'unknown';
+  type: 'unknown';
+};
+type Collection = {
+  category: 'collection';
+  type: 'List' | 'Map' | 'Set';
+  elementType: AttributeType;
+};
+type Nested = {
+  category: 'nested';
+  type: 'ListNested' | 'MapNested' | 'SetNested' | 'SingleNested';
+  modelTypeName: string;
+  validators: TerraformValidators;
+};
+type AttributeType = Nested | Collection | Dynamic | Primitive | Unknown;
+type TerraformDeclAttribute = BaseDeclaration & {
+  kind: 'TerraformDeclAttribute';
+  name: string;
+  docstring?: string;
+  type: AttributeType;
+  children: ID[];
+  configurability: Configurability;
+  requiresReplace?: boolean;
+};
+type TSDeclaration = TSDeclFunction | TSDeclClass | TSDeclInterface | TSDeclProperty | TSDeclTypeAlias | TSDeclReference | ErrorDecl;
+type TSDeclFunction = BaseDeclaration & {
+  kind: 'TSDeclFunction';
+  ident: TSIdentifier;
+  qualified?: string;
+  signature: TSFunctionSignature;
+  overloads?: TSFunctionSignature[];
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type TSDeclClass = BaseDeclaration & {
+  kind: 'TSDeclClass';
+  ident: TSIdentifier;
+  docstring?: string;
+  typeParameters?: TSTypeParameter[];
+  superClass?: TSTypeReference;
+  implements?: TSTypeReference[];
+  children: ID[];
+};
+type TSDeclInterface = BaseDeclaration & {
+  kind: 'TSDeclInterface';
+  ident: TSIdentifier;
+  docstring?: string;
+  typeParameters?: TSTypeParameter[];
+  extends?: TSType[];
+  children: ID[];
+};
+type TSDeclProperty = BaseDeclaration & {
+  kind: 'TSDeclProperty';
+  key: string;
+  docstring?: string;
+  title?: string;
+  type: TSType;
+  constraints?: Constraints;
+  optional?: boolean;
+  declare?: boolean;
+  default?: unknown;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type TSDeclTypeAlias = BaseDeclaration & {
+  kind: 'TSDeclTypeAlias';
+  docstring?: string;
+  ident: TSIdentifier;
+  typeParameters?: TSTypeParameter[];
+  type: TSType;
+  children?: ID[];
+};
+type TSDeclReference = BaseDeclaration & {
+  kind: 'TSDeclReference';
+  docstring?: string;
+  type: TSType;
+  children?: ID[];
+};
+type TSFunctionSignature = {
+  kind: 'TSFunctionSignature';
+  parameters: TSFunctionParameter[];
+  returns: TSType;
+  async?: boolean;
+  typeParameters?: TSTypeParameter[];
+  docstring?: string;
+};
+type TSFunctionParameter = {
+  kind: 'TSFunctionParameter';
+  ident: TSIdentifier;
+  type: TSType;
+  optional?: boolean;
+};
+type TSTypeParameter = {
+  kind: 'TSTypeParameter';
+  name: TSIdentifier;
+  constraint?: TSType;
+  default?: TSType;
+};
+type TSIdentifier = string;
+type TSType = TSTypeReference | TSTypeObject | TSTypeArray | TSTypeString | TSTypeNumber | TSTypeBoolean | TSTypeNull | TSTypeUndefined | TSTypeVoid | TSTypeAny | TSTypeUnknown | TSTypeNever | TSTypeLiteral | TSTypeUnion | TSTypeIntersection | TSTypeInterface;
+type TSTypeReference = BaseType & {
+  kind: 'TSTypeReference';
+  ident: TSIdentifier;
+  typeParameters?: TSType[];
+  schemaType?: SchemaType;
+  $ref?: ID;
+};
+type TSTypeObject = BaseType & {
+  kind: 'TSTypeObject';
+  members: {
+    ident: TSIdentifier;
+    type: TSType;
+    optional?: boolean;
+  }[];
+};
+type TSTypeArray = BaseType & {
+  kind: 'TSTypeArray';
+  elementType: TSType;
+};
+type TSTypeUnion = BaseType & {
+  kind: 'TSTypeUnion';
+  types: TSType[];
+};
+type TSTypeIntersection = BaseType & {
+  kind: 'TSTypeIntersection';
+  types: TSType[];
+};
+type TSTypeInterface = BaseType & {
+  kind: 'TSTypeInterface';
+  members: {
+    ident: TSIdentifier;
+    type: TSType;
+    optional?: boolean;
+  }[];
+  extends?: TSTypeReference[];
+};
+type TSTypeLiteral = BaseType & {
+  kind: 'TSTypeLiteral';
+  literal: string | boolean | number;
+};
+type TSTypeString = BaseType & {
+  kind: 'TSTypeString';
+};
+type TSTypeNumber = BaseType & {
+  kind: 'TSTypeNumber';
+};
+type TSTypeBoolean = BaseType & {
+  kind: 'TSTypeBoolean';
+};
+type TSTypeNull = BaseType & {
+  kind: 'TSTypeNull';
+};
+type TSTypeUndefined = BaseType & {
+  kind: 'TSTypeUndefined';
+};
+type TSTypeVoid = BaseType & {
+  kind: 'TSTypeVoid';
+};
+type TSTypeAny = BaseType & {
+  kind: 'TSTypeAny';
+};
+type TSTypeUnknown = BaseType & {
+  kind: 'TSTypeUnknown';
+};
+type TSTypeNever = BaseType & {
+  kind: 'TSTypeNever';
+};
+type HasOASRef = {
+  oasRef?: string;
+};
+type HasConfigRef = {
+  configRef: string;
+};
+type HasStainlessPath = {
+  stainlessPath: string;
+};
+type ID = string & {
+  _isId: null;
+};
+type SchemaType = SDKSchemaType;
+declare const constraints: readonly ['minLength', 'maxLength', 'format', 'minimum', 'exclusiveMinimum', 'maximum', 'exclusiveMaximum', 'multipleOf'];
+type Constraints = Pick<SchemaObject, (typeof constraints)[number]>;
+declare const SpecLanguages: readonly ['cli', 'csharp', 'go', 'http', 'java', 'kotlin', 'node', 'php', 'python', 'ruby', 'terraform', 'typescript'];
+type SpecLanguage = (typeof SpecLanguages)[number];
+declare const SnippetLanguages: readonly ['cli.default', 'csharp.default', 'go.default', 'http.curl', 'http.powershell', 'java.default', 'kotlin.default', 'node.default', 'php.default', 'python.default', 'ruby.default', 'terraform.default', 'typescript.default'];
+type SnippetLanguage<lang extends SpecLanguage = SpecLanguage> = (typeof SnippetLanguages)[number] & `${lang}.${string}`;
+/**
+ * A literal property path from Spec down to a given node
+ */
+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, {
+    default: {
+      content: string;
+    };
+    [key: `custom:${string}`]: {
+      content: string;
+    };
+  }> };
+  snippetResponses: {
+    http: Record<string, {
+      default?: {
+        status: string;
+        content: string;
+        contentType?: string;
+      }[];
+      [key: `custom:${string}`]: {
+        status?: string;
+        content: string;
+      }[];
+    }>;
+  };
+};
+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;
+} };
+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; /** @deprecated - use snippetResponses at the top level */
+  exampleResponses?: Record<string, ResponseContentObject>;
+  security: Record<string, string[]>[] | undefined;
+  'x-api-token-group'?: string[];
+} & { [key in SpecLanguage]?: {
+  Name: string;
+  QualifiedName: string;
+} };
+type Model = (HasOASRef & HasConfigRef & HasStainlessPath) & {
+  kind: 'model';
+  name: string;
+  title: string;
+  isImplicit: boolean;
+  stainlessPath: string;
+  configRef: string;
+  loading?: boolean;
+};
+type BaseDeclaration = {
+  stainlessPath: string;
+  oasRef?: string;
+  configRef?: string;
+  loading?: boolean;
+  deprecated?: boolean | string;
+  snippet?: string;
+};
+type BaseType = {
+  oasRef?: string;
+};
+type Diagnostics = Record<string, DiagnosticExport[]>;
+type LanguageDeclNodes = {
+  cli: CLIDeclaration;
+  csharp: CSharpDeclaration;
+  go: GoDeclaration;
+  http: HttpDeclaration;
+  java: JavaDeclaration;
+  kotlin: JavaDeclaration;
+  node: TSDeclaration;
+  php: PhpDeclaration;
+  python: PythonDeclaration;
+  ruby: RubyDeclaration;
+  terraform: TerraformDeclaration;
+  typescript: TSDeclaration;
+};
+type ErrorDecl = BaseDeclaration & {
+  kind: 'ErrorDecl';
+  error: Error;
+  message: string;
+};
+type GoDeclaration = GoDeclFunction | GoDeclType | GoDeclProperty | GoDeclTypeAlias | GoDeclConst | GoDeclReference | ErrorDecl;
+type GoDeclFunction = BaseDeclaration & {
+  kind: 'GoDeclFunction';
+  ident: GoIdentifier;
+  qualified?: string;
+  docstring?: string;
+  async?: boolean;
+  generics?: GoGenericParameter[];
+  parameters: GoFunctionParameter[];
+  returnType: GoType[];
+  paramsChildren?: ID[];
+  responseChildren?: ID[];
+};
+type GoFunctionParameter = {
+  kind: 'GoFunctionParameter';
+  optional?: boolean;
+  ident: GoIdentifier;
+  typeAnnotation: GoType;
+};
+type GoGenericParameter = {
+  kind: 'GoTypeParameter';
+  name: string;
+  constraint?: GoType;
+};
+type GoDeclType = BaseDeclaration & {
+  kind: 'GoDeclType';
+  docstring?: string;
+  ident: GoIdentifier;
+  generics?: GoGenericParameter[];
+  type: GoType;
+  children?: ID[];
+};
+type GoDeclTypeAlias = BaseDeclaration & {
+  kind: 'GoDeclTypeAlias';
+  docstring?: string;
+  ident: GoIdentifier;
+  type: GoType;
+  children?: ID[];
+};
+type GoDeclConst = BaseDeclaration & {
+  kind: 'GoDeclConst';
+  docstring?: string;
+  ident: GoIdentifier;
+  type: GoType;
+  value: boolean | string | number;
+  children?: ID[];
+};
+type GoIdentifier = string;
+type GoDeclProperty = BaseDeclaration & {
+  kind: 'GoDeclProperty';
+  docstring?: string;
+  title?: string;
+  ident: GoIdentifier;
+  type: GoType;
+  constraints?: Constraints;
+  optional?: boolean;
+  default?: unknown;
+  examples?: unknown[];
+  schemaType?: SchemaType;
+  modelPath?: string;
+  childrenParentSchema?: SchemaType;
+  children?: ID[];
+};
+type GoDeclReference = BaseDeclaration & {
+  kind: 'GoDeclReference';
+  docstring?: string;
+  type: GoType;
+  children?: ID[];
+};
+type GoType = GoTypeReference | GoTypeInterface | GoTypeStruct | GoTypeArray | GoTypeMap | GoTypeString | GoTypeFloat | GoTypeInt | GoTypeBool | GoTypeAny | GoTypeUnknown | GoTypeError | GoTypePointer;
+type GoTypeReference = BaseType & {
+  kind: 'GoTypeReference';
+  typeName: GoIdentifier;
+  typeParameters?: GoType[];
+  schemaType?: SchemaType;
+  $ref?: string;
+};
+type GoTypeStruct = BaseType & {
+  kind: 'GoTypeStruct';
+};
+type GoTypeInterface = BaseType & {
+  kind: 'GoTypeInterface';
+  docstring?: string;
+  typeName?: GoIdentifier;
+  generics?: GoGenericParameter[];
+  extends?: GoTypeReference[];
+};
+type GoTypeArray = BaseType & {
+  kind: 'GoTypeArray';
+  elementType: GoType;
+};
+type GoTypeMap = BaseType & {
+  kind: 'GoTypeMap';
+  indexType: GoType;
+  itemType: GoType;
+};
+type GoTypeString = BaseType & {
+  kind: 'GoTypeString';
+};
+type GoTypeFloat = BaseType & {
+  kind: 'GoTypeFloat';
+};
+type GoTypeInt = BaseType & {
+  kind: 'GoTypeInt';
+};
+type GoTypeBool = BaseType & {
+  kind: 'GoTypeBool';
+};
+type GoTypeAny = BaseType & {
+  kind: 'GoTypeAny';
+};
+type GoTypeUnknown = BaseType & {
+  kind: 'GoTypeUnknown';
+};
+type GoTypeError = BaseType & {
+  kind: 'GoTypeError';
+};
+type GoTypePointer = BaseType & {
+  kind: 'GoTypePointer';
+  inner: GoType;
+};
+//#endregion
+//#region src/types.d.ts
+type SearchSettings = {
+  appId: string;
+  searchKey: string;
+  indexName: string;
+  assistant?: string;
+};
+type SearchParams = {
+  query: string;
+  language?: DocsLanguage | null;
+  kind?: QueryKindsType | null;
+};
+declare const QueryKinds: readonly ["all", "guide", "resource", "http_method", "model", "property"];
+type QueryKindsType = (typeof QueryKinds)[number];
+type IndexModel = {
+  kind: 'model';
+  title: string;
+  children?: string[];
+  ident?: string;
+};
+type IndexProperty = {
+  kind: 'property';
+  docstring?: string;
+  type?: string;
+};
+type IndexResource = {
+  kind: 'resource';
+  title: string;
+  Name: string;
+  QualifiedName: string;
+};
+type IndexMethod = Pick<Method, 'kind' | 'summary' | 'description' | 'endpoint' | 'httpMethod'> & {
+  title: string;
+  qualified?: string;
+  ident?: string;
+};
+declare const SearchableAttributes: readonly ["name", "title", "ident", "Name", "qualified", "QualifiedName", "endpoint", "summary", "description", "docstring"];
+declare const SearchableAttributesChat: string[];
+declare const SearchableAttributesProse: string[];
+type SearchAttributeNames = (typeof SearchableAttributes)[number];
+type RoutableJsonNode = Method | Model | Resource;
+type IndexEntry = Pick<RoutableJsonNode, 'name' | 'stainlessPath'> & (IndexProperty | IndexModel | IndexResource | IndexMethod) & {
+  language: DocsLanguage;
+  priority: number;
+  crumbs: string[];
+};
+type ResultRecordType = IndexEntry & {
+  objectID: string;
+  _highlightResult: Record<SearchAttributeNames, {
+    value: string;
+  }>;
+};
+type ResultType = {
+  hits: ResultRecordType[];
+  facets?: Record<string, Record<string, number>>;
+  nbHits: number;
+};
+type GuideResultType = {
+  id: string;
+  score: number;
+  words: number[];
+  data: {
+    excerpt: string;
+    url: string;
+    word_count: number;
+    meta: {
+      title: string;
+    };
+    sub_results: {
+      url: string;
+      title: string;
+      excerpt: string;
+    }[];
+  };
+};
+type ResultData = {
+  items: Array<ResultRecordType | GuideResultType>;
+  counts: Partial<Record<QueryKindsType, number>>;
+};
+type ProseIndexEntry = {
+  id?: string;
+  tag: string;
+  content: string;
+  source?: string;
+  [additional: string]: unknown;
+};
+//#endregion
+export { SearchableAttributes as _, IndexProperty as a, Resource as b, QueryKinds as c, ResultRecordType as d, ResultType as f, SearchSettings as g, SearchParams as h, IndexModel as i, QueryKindsType as l, SearchAttributeNames as m, IndexEntry as n, IndexResource as o, RoutableJsonNode as p, IndexMethod as r, ProseIndexEntry as s, GuideResultType as t, ResultData as u, SearchableAttributesChat as v, Spec as x, SearchableAttributesProse as y };