import * as _$_nestjs_common0 from "@nestjs/common";
import { ArgumentMetadata, ArgumentsHost, DynamicModule, ExceptionFilter, HttpStatus, OnApplicationBootstrap, OnModuleDestroy, OnModuleInit, PipeTransform, Type, ValidationPipe, ValidationPipeOptions } from "@nestjs/common";
import { AnyEntity, Collection, Config, Cursor, DefineConfig, EmbeddedOptions, EntityManager, EntityName, EnumOptions, Hidden, HiddenProps, Loaded, ManyToManyOptions, ManyToOneOptions, MikroORM, OneToManyOptions, OneToOneOptions, Opt, OptionalProps, Options, Primary, PrimaryKeyProp, PrimaryProperty, PropertyOptions, QueryOrderMap, Ref } from "@mikro-orm/core";
import { ValidationOptions } from "class-validator";
import { ApiPropertyOptions, OpenAPIObject } from "@nestjs/swagger";
import { Keq, KeqMiddleware, KeqOperation, KeqPathParameterInit, KeqQueryInit, KeqRequest, RequestException } from "keq";
import { KeqConsumer, KeqModuleOptions } from "@keq-request/nestjs";
import { Base32, ErrorCategory, ErrorCategory as ErrorCategory$1, ErrorCode, ErrorCode as ErrorCode$1, ErrorCodeOptions } from "@buka/error-codes";
import { Exception, ExceptionDetail, ExceptionDetail as ExceptionDetail$1, ExceptionOptions as ExceptionOptions$1 } from "@buka/exception";
import { Logger, LoggerErrorInterceptor } from "nestjs-pino";
import { Readable } from "node:stream";
import * as _$type_fest0 from "type-fest";
import { Class, JsonValue, ValueOf } from "type-fest";
import { IncomingMessage } from "http";

//#region src/swagger-patcher/deep-objectify-queries.d.ts
/**
 * 将 OpenAPI 文档中 query 参数中的对象和数组类型自动设置为 `style: 'deepObject'`。
 *
 * NestJS Swagger 生成的文档默认不会为复杂 query 参数设置 `style`，
 * 导致部分客户端生成器无法正确序列化嵌套查询参数。
 *
 * @param openapi - OpenAPI 文档对象（会被原地修改）
 *
 * @example
 * ```typescript
 * const document = SwaggerModule.createDocument(app, config)
 * SwaggerPatcher.deepObjectifyQueries(document)
 * SwaggerModule.setup('api', app, document)
 * ```
 */
declare function deepObjectifyQueries(openapi: OpenAPIObject): void;
//#endregion
//#region src/swagger-patcher/unify-exception-responses.d.ts
interface UnifyExceptionResponsesOptions {
  /** 覆写已有的哪些响应，支持 `'4xx'`、`'5xx'`、`'default'` 或具体数字状态码，默认 `[]` */
  overwrite?: ('4xx' | '5xx' | 'default' | number)[];
  /** 插入新的状态码响应（无论是否已存在），默认 `[]` */
  insert?: (number | 'default')[];
}
/**
 * 将统一异常响应结构注入 OpenAPI 文档。
 *
 * 在 `components.schemas` 注册 `ExceptionResponse` schema，
 * 在 `components.responses` 注册可复用的 `ExceptionResponse` 响应对象，
 * 并根据选项覆写或插入 operation 的异常响应。
 *
 * @param openapi - OpenAPI 文档对象（会被原地修改）
 * @param options - 控制覆写和插入行为
 * @param options.overwrite - 覆写已有的哪些响应，支持 `'4xx'`、`'5xx'`、`'default'` 或具体数字状态码，默认 `[]`
 * @param options.insert - 插入新的状态码响应（无论是否已存在），默认 `[]`
 *
 * @example
 * ```typescript
 * const document = SwaggerModule.createDocument(app, config)
 *
 * // 仅注册组件，不修改 operations
 * SwaggerPatcher.unifyExceptionResponses(document)
 *
 * // 为所有 operation 插入 401, 403, 500
 * SwaggerPatcher.unifyExceptionResponses(document, {
 *   insert: [401, 403, 500],
 * })
 *
 * // 覆写已有的 4xx/5xx 响应
 * SwaggerPatcher.unifyExceptionResponses(document, {
 *   overwrite: ['4xx', '5xx'],
 * })
 *
 * // 覆写 5xx + 插入 401, 403
 * SwaggerPatcher.unifyExceptionResponses(document, {
 *   overwrite: ['5xx'],
 *   insert: [401, 403],
 * })
 * ```
 */
declare function unifyExceptionResponses(openapi: OpenAPIObject, options?: UnifyExceptionResponsesOptions): void;
//#endregion
//#region src/swagger-patcher/openapi-helpers.d.ts
type ReferenceObject = {
  $ref: string;
};
type SchemaObject = Exclude<ValueOf<Required<Required<OpenAPIObject>['components']>['schemas']>, ReferenceObject>;
//#endregion
//#region src/swagger-patcher/swagger-patcher.d.ts
/**
 * Swagger/OpenAPI 文档修补工具，用于修正生成的 OpenAPI 文档中的已知问题。
 */
declare class SwaggerPatcher {
  static deepObjectifyQueries: typeof deepObjectifyQueries;
  static unifyExceptionResponses: typeof unifyExceptionResponses;
}
//#endregion
//#region src/modules/core/buka-module-options.d.ts
interface BukaModuleOptions {
  validation?: ValidationPipeOptions;
}
//#endregion
//#region src/modules/core/buka.module-definition.d.ts
declare const BukaConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<BukaModuleOptions, "register", "create", {}>, BUKA_MODULE_OPTIONS_TOKEN: string | symbol;
//#endregion
//#region src/modules/core/buka.module.d.ts
declare class BukaModule extends BukaConfigurableModuleClass {}
//#endregion
//#region src/modules/core/constants/offset-page-schema.d.ts
declare const OffsetPageSchema: {
  type: string;
  properties: {
    limit: {
      type: string;
    };
    offset: {
      type: string;
    };
  };
  required: string[];
  additionalProperties: boolean;
};
//#endregion
//#region src/modules/core/constants/next-cursor-page-schema.d.ts
declare const NextCursorPageSchema: {
  type: string;
  properties: {
    after: {
      type: string;
    };
    first: {
      type: string;
    };
  };
  required: string[];
  additionalProperties: boolean;
};
//#endregion
//#region src/modules/core/constants/previous-cursor-page-schema.d.ts
declare const PreviousCursorPageSchema: {
  type: string;
  properties: {
    before: {
      type: string;
    };
    last: {
      type: string;
    };
  };
  required: string[];
  additionalProperties: boolean;
};
//#endregion
//#region src/modules/core/decorators/class-validator/has-any-key.d.ts
declare const HAS_ANY_KEY = "hasAnyKey";
/**
 * 验证对象至少包含指定 key 中的一个。
 *
 * @param keys - 允许的 key 列表，对象中至少需存在其一
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * class FilterDTO {
 *   @HasAnyKey(['$eq', '$ne', '$in'])
 *   name: { $eq?: string; $ne?: string; $in?: string[] }
 * }
 * ```
 */
declare function HasAnyKey(keys: readonly string[], validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
//#endregion
//#region src/modules/core/decorators/class-validator/is-crockford-base32.d.ts
declare const IS_CROCKFORD_BASE32 = "isCrockfordBase32";
/**
 * 验证字符串是否为合法的 Crockford Base32 编码。
 *
 * Crockford Base32 使用字符集 `0-9A-HJKMNP-TV-Z`，常用于 ULID 等场景。
 *
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * class EntityDTO {
 *   @IsCrockfordBase32()
 *   id: string
 * }
 * ```
 */
declare function IsCrockfordBase32(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
//#endregion
//#region src/modules/core/decorators/class-validator/is-enum-column.d.ts
declare const IS_ENUM_COLUMN = "isEnumColumn";
/**
 * 枚举列验证器，验证单个值是否为合法的枚举值。
 *
 * 延迟解析 `items`（在验证阶段才调用工厂函数），避免装饰器阶段因循环引用报错。
 * 同时兼容两种写法：枚举对象 `() => Status` 和值数组 `() => Object.values(Status)`。
 *
 * 验证逻辑委托给 class-validator 内置的 `isEnum` / `Array.includes`。
 * 如需校验数组，配合 `IsArray()` 和 `{ each: true }` 使用。
 *
 * @param items - 枚举对象、值数组，或返回它们的工厂函数
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * // 单值校验
 * class MyDto {
 *   @IsEnumColumn(() => Status)
 *   status: Status
 * }
 *
 * // 数组校验
 * class MyDto {
 *   @IsArray()
 *   @IsEnumColumn(() => Status, { each: true })
 *   statuses: Status[]
 * }
 * ```
 */
declare function IsEnumColumn(items: (() => object | (string | number)[]) | object | (string | number)[], validationOptions?: ValidationOptions): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/class-validator/is-scalar.d.ts
type ScalarClass = typeof String | typeof Number | typeof Boolean;
type ExcludeScalarClass<T> = T extends ScalarClass ? never : T;
declare function isScalarClass(ctor: (() => Class<object>) | ScalarClass): ctor is ScalarClass;
/**
 * 根据标量类型（`String` / `Number` / `Boolean`）自动应用对应的 class-validator 验证装饰器。
 *
 * @param ctor - 标量构造函数：`String`、`Number` 或 `Boolean`
 * @param each - 是否对数组中的每个元素进行验证
 * @returns 对应的 `@IsString()` / `@IsNumber()` / `@IsBoolean()` 装饰器
 *
 * @example
 * ```typescript
 * class MyModel {
 *   @IsScalar(String, true)
 *   tags: string[]
 * }
 * ```
 */
declare function IsScalar(ctor: ScalarClass, each: boolean): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/class-validator/is-scalar-dictionary.d.ts
declare const IS_SCALAR_DICTIONARY = "isScalarDictionary";
/**
 * 验证普通对象（Record）中的每个 value 是否为指定的标量类型。
 *
 * 与 class-validator 内置的 `{ each: true }` 不同，此验证器通过 `Object.values()` 遍历普通对象的值，
 * 而非仅支持 Array / Map / Set。
 *
 * @param ctor - 标量构造函数：`String`、`Number` 或 `Boolean`
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * class ConfigDTO {
 *   @IsScalarDictionary(String)
 *   metadata: Record<string, string>
 * }
 * ```
 */
declare function IsScalarDictionary(ctor: ScalarClass, validationOptions?: ValidationOptions): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/class-validator/is-urn.d.ts
declare const IS_URN = "isUrn";
declare const IS_DOMAIN_URN = "isDomainUrn";
/**
 * 验证字符串是否为合法的 URN（任意层级）。
 *
 * @example
 * ```typescript
 * class TokenPayloadDTO {
 *   @IsUrn()
 *   sub: string
 * }
 * ```
 */
declare function IsUrn(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
/**
 * 验证字符串是否为概念域级 URN（仅含 domain，无 resourceType 和 resourceId）。
 *
 * @example
 * ```typescript
 * class TokenPayloadDTO {
 *   @IsDomainUrn()
 *   aud: string
 * }
 * ```
 */
declare function IsDomainUrn(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
/**
 * 验证字符串是否匹配指定的 URN 模式（支持通配符 `*` 和 `**`）。
 *
 * - `*` 匹配恰好一个段
 * - `**` 匹配零个或多个尾部段
 *
 * @example
 * ```typescript
 * class CreateClientDTO {
 *   @MatchesUrn('urn:buka:galaxy:client:*')
 *   clientUrn: string
 * }
 * ```
 */
declare function MatchesUrn(pattern: string, validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
//#endregion
//#region src/modules/core/decorators/class-validator/match-json-schema.d.ts
declare const MATCH_JSON_SCHEMA = "matchJsonSchema";
/**
 * 验证属性值是否符合给定的 JSON Schema。
 *
 * @param schema - JSON Schema 定义
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * class ConfigDTO {
 *   @MatchJsonSchema({
 *     type: 'object',
 *     properties: { key: { type: 'string' } },
 *     required: ['key'],
 *   })
 *   config: Record<string, any>
 * }
 * ```
 */
declare function MatchJsonSchema(schema: any, validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
//#endregion
//#region src/modules/core/decorators/class-validator/validate-nested-dictionary.d.ts
declare const VALIDATE_NESTED_DICTIONARY = "validateNestedDictionary";
/**
 * 验证普通对象（Record）中的每个 value 是否为有效的嵌套对象实例。
 *
 * 通过 `Object.values()` 遍历字典值，对每个值调用 `validateSync()` 进行嵌套验证。
 * 与 class-validator 内置的 `@ValidateNested({ each: true })` 不同，此验证器支持普通对象，
 * 而非仅支持 Array / Map / Set。
 *
 * @param typeFunc - 延迟求值的嵌套类型引用 `() => Class`
 * @param validationOptions - class-validator 的验证选项
 *
 * @example
 * ```typescript
 * class UserDTO {
 *   @ValidateNestedDictionary(() => AddressDTO)
 *   addresses: Record<string, AddressDTO>
 * }
 * ```
 */
declare function ValidateNestedDictionary(typeFunc: () => Class<object>, validationOptions?: ValidationOptions): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/is-browser-request.d.ts
/**
 * 参数装饰器，通过检测请求头中是否存在 `Sec-Fetch-Site` 头，
 * 判断请求是否来自浏览器。
 *
 * 浏览器在发起请求时会自动附加 `Sec-Fetch-Site`、`Sec-Fetch-Mode`、
 * `Sec-Fetch-Dest` 等头（[Fetch Metadata Request Headers](https://www.w3.org/TR/fetch-metadata/)）。
 * 非浏览器客户端（如 curl、Postman）通常不会携带这些头。
 *
 * **注意：** Node.js 的 undici（globalThis.fetch）会自动添加 `Sec-Fetch-Mode: cors`，
 * 但不会添加 `Sec-Fetch-Site`。因此使用 `Sec-Fetch-Site` 而非任意 `Sec-Fetch-*`
 * 头来区分真正的浏览器请求和服务端 fetch 调用。
 *
 * 装饰的参数类型应为 `boolean`。
 *
 * @example
 * ```typescript
 * @Controller('users')
 * class UserController {
 *   @Get('me')
 *   getMe(@IsBrowserRequest() isBrowser: boolean) {
 *     if (isBrowser) {
 *       // 浏览器请求，可返回完整的页面数据
 *     }
 *   }
 * }
 * ```
 */
declare const IsBrowserRequest: (...dataOrPipes: unknown[]) => ParameterDecorator;
//#endregion
//#region src/modules/core/decorators/model/model.decorator.d.ts
interface ModelSchemaOptions {
  description?: string;
  additionalProperties?: boolean;
}
interface ModelMetadata {
  propertyKeys: (string | symbol)[];
  schema?: ModelSchemaOptions;
  additionalProperties?: boolean | (() => Class<object>);
}
interface ModelOptions {
  /**
   * Swagger/OpenAPI schema 配置，透传给 `@ApiSchema()`。
   * 仅影响文档生成，不影响运行时序列化行为。
   */
  schema?: ModelSchemaOptions;
  /**
   * 控制序列化时是否保留未通过 `@Property`/`@Composite` 等装饰器注册的额外字段。
   *
   * - `true`：额外字段原样保留
   * - `() => Class`：额外字段按指定 Model 类型递归序列化
   * - 未设置（默认）：额外字段在序列化时被丢弃
   */
  additionalProperties?: boolean | (() => Class<object>);
}
/**
 * 模型类装饰器，标记一个 class 为模型，使其可被 Converter（如 `PickType`、`OmitType`）识别和处理。
 *
 * @param options - 可选的模型配置
 *
 * @example
 * ```typescript
 * @Model({ schema: { description: '用户信息' } })
 * class UserDTO {
 *   @Property()
 *   name: string
 * }
 * ```
 */
declare function Model(options?: ModelOptions): ClassDecorator;
//#endregion
//#region src/modules/core/decorators/model/association.decorator.d.ts
interface RefAssociationMetadata {
  kind: '1:1' | 'm:1';
  type: () => Class<object>;
}
interface CollectionAssociationMetadata {
  kind: '1:m' | 'm:n';
  type: () => Class<object>;
}
type AssociationMetadata = RefAssociationMetadata | CollectionAssociationMetadata;
//#endregion
//#region src/modules/core/decorators/model/property.decorator.d.ts
interface PropertyMetadataBase {
  optional: boolean;
  lazy: boolean;
  association?: AssociationMetadata;
}
interface ScalarPropertyMetadata extends PropertyMetadataBase {
  kind: 'scalar';
}
interface CompositePropertyMetadata extends PropertyMetadataBase {
  kind: 'composite';
  type: () => Class<object>;
}
interface ListPropertyMetadata extends PropertyMetadataBase {
  kind: 'list';
  type?: (() => Class<object>) | ScalarClass;
}
interface DictionaryPropertyMetadata extends PropertyMetadataBase {
  kind: 'dictionary';
  type?: (() => Class<object>) | ScalarClass;
  map?: boolean;
}
interface EnumPropertyMetadata extends PropertyMetadataBase {
  kind: 'enum';
  type?: () => object;
  values?: (string | number)[];
  /**
   * MikroORM `@Enum()` 列装饰器传入的原始 `items` 参数。
   * 保持原始格式（数组或惰性函数），不立即求值以避免循环引用。
   */
  items?: (() => (string | number)[]) | (string | number)[];
  enumName?: string;
  array?: boolean;
}
type PropertyMetadata = ScalarPropertyMetadata | CompositePropertyMetadata | ListPropertyMetadata | DictionaryPropertyMetadata | EnumPropertyMetadata;
type PropertyKind = 'scalar' | 'composite' | 'list' | 'dictionary' | 'enum';
interface ScalarPropertyOptions {
  /**
   * 是否可选。为 `true` 时自动应用 `@IsOptional()` 和 `@ApiPropertyOptional()`。
   */
  optional?: boolean;
  /**
   * 标记该属性为懒加载。懒加载属性存在除 `undefined` 之外的第三种状态——"未加载"，
   * 即该属性并非不存在，而是尚未被加载。懒加载属性默认不注册 Swagger schema，
   * 因此不会出现在 API 文档中。如需包含，请在派生 DTO 中手动声明。
   *
   * 在 MikroORM 场景下，对应 `lazy: true` 的列，查询时不会默认 SELECT 该列，需显式 `populate` 才会加载。
   */
  lazy?: boolean;
  /**
   * 自定义 Swagger schema 配置，透传给 `@ApiProperty()` / `@ApiPropertyOptional()`。
   */
  schema?: ApiPropertyOptions;
}
/**
 * 标量属性装饰器，用于声明模型中的基础类型属性（如 `string`、`number`、`boolean`）。
 *
 * 自动注册属性元数据，并根据 `optional` 和 `schema` 配置应用 class-validator 和 Swagger 装饰器。
 *
 * @param options - 标量属性配置
 *
 * @example
 * ```typescript
 * @Model()
 * class UserDTO {
 *   @Property()
 *   name: string
 *
 *   @Property({ optional: true, schema: { description: '用户年龄' } })
 *   age?: number
 * }
 * ```
 */
declare function Property(options?: ScalarPropertyOptions): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/model/model.register.d.ts
declare class ModelRegister {
  static setModel(target: Class<any>, metadata: ModelMetadata): void;
  static getModel(target: Class<any>): ModelMetadata | undefined;
  static setProperty(target: Class<any>, propertyName: string | symbol, metadata: PropertyMetadata): void;
  static getProperty(target: Class<any>, propertyName: string | symbol): PropertyMetadata | undefined;
  static copyProperty(source: Class<any>, target: Class<any>, propertyName: string | symbol): void;
  static addModel(target: Class<any>): ModelMetadata;
  static addProperty(target: Class<any>, propertyName: string | symbol, metadata: PropertyMetadata): void;
  /**
   * 判断是否为已注册的 Model
   *
   * @example
   * ```typescript
   * const isModel = ModelRegister.isModel(Class.prototype)
   * ```
   */
  static isModel(target: Class<any>): boolean;
  /**
   * 获取 Model 的所有属性
   *
   * @example
   * ```typescript
   * const properties = ModelRegister.getProperties(Class.prototype)
   * ```
   */
  static getModelPropertyKeys(target: Class<any>): (string | symbol)[];
  static getProperties(target: Class<any>): PropertyMetadata[];
}
//#endregion
//#region src/modules/core/decorators/model/composite.decorator.d.ts
interface CompositeOptions {
  /**
   * 复合类型的 class 引用，使用延迟求值函数 `() => Class` 以避免循环依赖。
   */
  type: () => Class<object>;
  /**
   * 是否可选。为 `true` 时自动应用 `@IsOptional()` 和 `@ApiPropertyOptional()`。
   */
  optional?: boolean;
  /**
   * 标记该属性为懒加载。懒加载属性存在除 `undefined` 之外的第三种状态——"未加载"，
   * 即该属性并非不存在，而是尚未被加载。懒加载属性默认不注册 Swagger schema，
   * 因此不会出现在 API 文档中。如需包含，请在派生 DTO 中手动声明。
   *
   * 在 MikroORM 场景下，对应 `lazy: true` 的列，查询时不会默认 SELECT 该列，需显式 `populate` 才会加载。
   */
  lazy?: boolean;
  /**
   * 自定义 Swagger schema 配置，透传给 `@ApiProperty()` / `@ApiPropertyOptional()`。
   */
  schema?: ApiPropertyOptions;
  /**
   * 关联元数据，由 Cardinality 装饰器内部传入，通常无需手动设置。
   */
  association?: RefAssociationMetadata;
}
/**
 * 复合类型属性装饰器，用于声明嵌套对象类型的属性。
 *
 * 自动应用 `@ValidateNested()`、`@Type()` 以及 Swagger schema 配置，支持递归验证嵌套对象。
 *
 * @param options - 复合类型配置，必须通过 `type` 指定嵌套类的引用
 *
 * @example
 * ```typescript
 * @Model()
 * class AddressDTO {
 *   @Property()
 *   city: string
 * }
 *
 * @Model()
 * class UserDTO {
 *   @Composite({ type: () => AddressDTO })
 *   address: AddressDTO
 * }
 * ```
 */
declare function Composite(options: CompositeOptions): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/model/list.decorator.d.ts
interface ListOptionsBase {
  /**
   * 是否可选。为 `true` 时自动应用 `@IsOptional()` 和 `@ApiPropertyOptional()`。
   */
  optional?: boolean;
  /**
   * 标记该属性为懒加载。懒加载属性存在除 `undefined` 之外的第三种状态——"未加载"，
   * 即该属性并非不存在，而是尚未被加载。懒加载属性默认不注册 Swagger schema，
   * 因此不会出现在 API 文档中。如需包含，请在派生 DTO 中手动声明。
   *
   * 在 MikroORM 场景下，对应 `lazy: true` 的列，查询时不会默认 SELECT 该列，需显式 `populate` 才会加载。
   */
  lazy?: boolean;
  /**
   * 自定义 Swagger schema 配置，透传给 `@ApiProperty()` / `@ApiPropertyOptional()`。
   */
  schema?: ApiPropertyOptions;
  /**
   * 关联元数据，由 Cardinality 装饰器内部传入，通常无需手动设置。
   */
  association?: CollectionAssociationMetadata;
}
interface ListOptionsScalar extends ListOptionsBase {
  /**
   * 标量类型：`String` / `Number` / `Boolean`。
   */
  type: ScalarClass;
}
interface ListOptionsComposite<T extends Class<object>> extends ListOptionsBase {
  /**
   * 复合类型：`() => Class`。
   */
  type: () => ExcludeScalarClass<T>;
}
/**
 * 列表（数组）属性装饰器，支持无类型、标量类型和复合类型三种模式。
 *
 * - 无类型：不指定 `type`，仅校验为数组
 * - 标量类型：`type` 为 `String` / `Number` / `Boolean`
 * - 复合类型：`type` 为 `() => Class`，支持嵌套验证
 *
 * @param options - 列表属性配置
 *
 * @example
 * ```typescript
 * @Model()
 * class UserDTO {
 *   @List({ type: String })
 *   tags: string[]
 *
 *   @List({ type: () => AddressDTO })
 *   addresses: AddressDTO[]
 * }
 * ```
 */
declare function List<T extends Class<object>>(options?: ListOptionsBase | ListOptionsScalar | ListOptionsComposite<T>): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/model/dictionary.decorator.d.ts
interface DictionaryOptionsBase {
  /**
   * 是否可选。为 `true` 时自动应用 `@IsOptional()` 和 `@ApiPropertyOptional()`。
   */
  optional?: boolean;
  /**
   * 标记该属性为懒加载。懒加载属性存在除 `undefined` 之外的第三种状态——"未加载"，
   * 即该属性并非不存在，而是尚未被加载。懒加载属性默认不注册 Swagger schema，
   * 因此不会出现在 API 文档中。如需包含，请在派生 DTO 中手动声明。
   *
   * 在 MikroORM 场景下，对应 `lazy: true` 的列，查询时不会默认 SELECT 该列，需显式 `populate` 才会加载。
   */
  lazy?: boolean;
  /**
   * 自定义 Swagger schema 配置，透传给 `@ApiProperty()` / `@ApiPropertyOptional()`。
   */
  schema?: ApiPropertyOptions;
  /**
   * 关联元数据，由 Cardinality 装饰器内部传入，通常无需手动设置。
   */
  association?: AssociationMetadata;
  /**
   * 启用 Map 模式。为 `true` 时使用 `Map<string, T>` 代替 `Record<string, T>`，
   * 复用 class-validator / class-transformer 的原生 Map 支持，可获得完整的嵌套错误路径。
   *
   * @default false
   */
  map?: boolean;
}
interface DictionaryOptionsScalar extends DictionaryOptionsBase {
  /**
   * 标量类型：`String` / `Number` / `Boolean`。
   */
  type: ScalarClass;
}
interface DictionaryOptionsComposite<T extends Class<object>> extends DictionaryOptionsBase {
  /**
   * 复合类型：`() => Class`。
   */
  type: () => ExcludeScalarClass<T>;
}
/**
 * 字典（键值对）属性装饰器，支持无类型、标量类型和复合类型三种模式。
 *
 * - 无类型：不指定 `type`，仅校验为对象
 * - 标量类型：`type` 为 `String` / `Number` / `Boolean`
 * - 复合类型：`type` 为 `() => Class`，支持嵌套验证
 *
 * @param options - 字典属性配置
 *
 * @example
 * ```typescript
 * @Model()
 * class UserDTO {
 *   @Dictionary({ type: String })
 *   metadata: Record<string, string>
 *
 *   @Dictionary({ type: () => AddressDTO, optional: true })
 *   addressMap?: Record<string, AddressDTO>
 * }
 * ```
 */
declare function Dictionary<T extends Class<object>>(options?: DictionaryOptionsBase | DictionaryOptionsScalar | DictionaryOptionsComposite<T>): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/model/enum.decorator.d.ts
interface EnumOptionsBase {
  /**
   * 是否可选。为 `true` 时自动应用 `@IsOptional()` 和 `@ApiPropertyOptional()`。
   */
  optional?: boolean;
  /**
   * 标记该属性为懒加载。懒加载属性存在除 `undefined` 之外的第三种状态——"未加载"，
   * 即该属性并非不存在，而是尚未被加载。懒加载属性默认不注册 Swagger schema，
   * 因此不会出现在 API 文档中。如需包含，请在派生 DTO 中手动声明。
   *
   * 在 MikroORM 场景下，对应 `lazy: true` 的列，查询时不会默认 SELECT 该列，需显式 `populate` 才会加载。
   */
  lazy?: boolean;
  /**
   * 自定义 Swagger schema 配置，透传给 `@ApiProperty()` / `@ApiPropertyOptional()`。
   */
  schema?: ApiPropertyOptions;
  /**
   * Swagger 中枚举的名称，用于生成 `$ref` 引用的命名 schema。
   * 例如 `enumName: 'Status'` 会在 Swagger 的 components/schemas 中生成命名枚举。
   */
  enumName?: string;
}
interface EnumOptionsTyped extends EnumOptionsBase {
  /**
   * 枚举类型的延迟求值函数，传入 `() => EnumObject` 以避免循环依赖。
   * 内部使用 `@IsEnum()` 进行校验。
   */
  type: () => object;
  values?: never;
}
interface EnumOptionsValues extends EnumOptionsBase {
  /**
   * 枚举的允许值数组。内部使用 `@IsIn()` 进行校验。
   */
  values: (string | number)[];
  type?: never;
}
type EnumOptions$1 = EnumOptionsTyped | EnumOptionsValues;
/**
 * 枚举属性装饰器，支持 TypeScript enum 对象和值数组两种方式。
 *
 * @example
 * ```typescript
 * enum Status { Active = 'active', Inactive = 'inactive' }
 *
 * class MyModel {
 *   // 方式1: 传入 TS enum
 *   @Enum({ type: () => Status })
 *   status: Status
 *
 *   // 方式2: 传入值数组
 *   @Enum({ values: ['low', 'medium', 'high'] })
 *   priority: string
 * }
 * ```
 */
declare function Enum(options: EnumOptions$1): PropertyDecorator;
//#endregion
//#region src/modules/core/decorators/model/model.serializer.d.ts
/**
 * 序列化 Model 实例为普通 JSON 对象。
 *
 * 处理三种情况：
 * 1. Ref<Entity> 包装 → populated 时完整序列化，否则返回主键
 * 2. 普通 MikroORM 实体（find 返回的）→ toJSON() 完整序列化
 * 3. 非 MikroORM 值 → 按 @Model 注册的属性元数据递归序列化
 */
declare function serializeModel(value: any, classRef: Class<any>): any;
//#endregion
//#region src/modules/core/decorators/page-query.d.ts
/**
 * 分页查询参数装饰器，从 query string 中提取并验证分页参数。
 *
 * 支持 offset 分页（`limit` + `offset`）和 cursor 分页（`after`/`before` + `first`/`last`）两种模式。
 * 未指定 `mode` 时同时支持两种分页方式。
 *
 * @param mode - 分页模式：`'cursor'` 或 `'offset'`，不传则同时支持两种
 *
 * @example
 * ```typescript
 * @Controller('users')
 * class UserController {
 *   @Get()
 *   findAll(@PageQuery('offset') page: { limit: number; offset: number }) {
 *     return this.userService.findAll(page)
 *   }
 * }
 * ```
 */
declare function PageQuery(mode?: 'cursor' | 'offset'): ParameterDecorator;
/**
 * 可选的分页查询参数装饰器，与 `@PageQuery()` 相同但允许不传分页参数。
 *
 * @param mode - 分页模式：`'cursor'` 或 `'offset'`，不传则同时支持两种
 *
 * @example
 * ```typescript
 * @Controller('users')
 * class UserController {
 *   @Get()
 *   findAll(@OptionalPageQuery('offset') page?: { limit: number; offset: number }) {
 *     return this.userService.findAll(page)
 *   }
 * }
 * ```
 */
declare function OptionalPageQuery(mode?: 'cursor' | 'offset'): ParameterDecorator;
//#endregion
//#region src/modules/core/decorators/filter-query.d.ts
/**
 * 过滤查询参数装饰器，从 query string 中提取 `filter` 参数，
 * 将前端传入的无前缀操作符（`eq`、`ne`、`gte`）自动转换为后端的 `$eq`、`$ne`、`$gte` 格式。
 *
 * @param classRef - 使用 `@Model()` 标注的类引用
 *
 * @example
 * ```typescript
 * @Controller('users')
 * class UserController {
 *   @Get()
 *   findAll(@FilterQuery(User) query: IFilterQuery<User>) {
 *     // HTTP: ?filter={"name":{"eq":"Alice"}}
 *     // query.filter?.name?.$eq === 'Alice'
 *   }
 * }
 * ```
 */
declare function FilterQuery<T>(classRef: Class<T>): ParameterDecorator;
//#endregion
//#region src/modules/core/pipes/validation.pipe.d.ts
/**
 * 增强的验证管道，在 NestJS `ValidationPipe` 基础上增加了 MikroORM 实体引用自动转换能力。
 *
 * 验证通过后，会自动将嵌套对象中包含主键的属性转换为 MikroORM 的 `Reference` 对象。
 *
 * @example
 * ```typescript
 * // 在 NestJS 模块中全局注册
 * app.useGlobalPipes(new BukaValidationPipe(orm, em, { transform: true }))
 * ```
 */
declare class BukaValidationPipe extends ValidationPipe implements PipeTransform {
  private readonly orm;
  private readonly em;
  private readonly logger;
  private readonly validationOptions?;
  constructor(orm: MikroORM, em: EntityManager, options?: ValidationPipeOptions);
  transform(value: any, metadata: ArgumentMetadata): Promise<any>;
}
//#endregion
//#region src/modules/core/pipes/page-query-validation.pipe.d.ts
interface BukaPageQueryValidationPipeOptions {
  mode?: 'cursor' | 'offset';
  optional?: boolean;
}
/**
 * 分页查询参数验证管道，校验并解析 query string 中的分页参数。
 *
 * 支持 offset 分页（`limit` + `offset`）和 cursor 分页（`after`/`before` + `first`/`last`），
 * 自动将字符串参数转换为数值类型。通常由 `@PageQuery()` 装饰器内部使用。
 *
 * @example
 * ```typescript
 * // 一般通过 @PageQuery() 装饰器间接使用
 * @Get()
 * findAll(@PageQuery('offset') page: { limit: number; offset: number }) {}
 * ```
 */
declare class BukaPageQueryValidationPipe implements PipeTransform {
  private readonly options;
  constructor(options?: BukaPageQueryValidationPipeOptions);
  transform(value: any, metadata: ArgumentMetadata): any;
}
//#endregion
//#region src/modules/core/converters/filter-query-type/types/filter-query.d.ts
/**
 * 标量字段的比较操作符。
 *
 * @typeParam T - 标量值类型（如 string、number、Date）
 */
interface IScalarOperator<T> {
  $lt?: T;
  $gt?: T;
  $lte?: T;
  $gte?: T;
  $eq?: T;
  $ne?: T;
  $in?: T[];
  $nin?: T[];
}
/**
 * 集合字段的量化操作符。
 *
 * @typeParam T - 集合元素的类型
 */
interface ICollectionOperator<T> {
  $some?: INestedOperator<T>;
  $every?: INestedOperator<T>;
  $none?: INestedOperator<T>;
}
/**
 * 嵌套属性操作符分发。
 *
 * - 数组 → {@link ICollectionOperator}<元素类型>
 * - 非数组 → {@link IObjectOperator}<T>（递归展开实体属性）
 *
 * @typeParam T - 待分发的属性类型
 */
type INestedOperator<T> = T extends Array<infer U> ? ICollectionOperator<U> : IObjectOperator<T>;
/**
 * MikroORM 标量类型联合。
 *
 * 命中此白名单 → {@link IScalarOperator}（生成 $eq/$ne 等比较操作符）。
 * 未命中 → {@link IObjectOperator}（递归展开，适用于 @Composite + @Model 嵌套 filter）。
 */
type MikroOrmScalar = string | number | boolean | Date | bigint | Buffer | null | undefined;
/**
 * 判断 T 是否为 MikroORM 标量类型。
 *
 * @typeParam T - 待判断的类型
 */
type IsMikroOrmScalar<T> = [T] extends [MikroOrmScalar] ? true : false;
/**
 * 判断 T 是否为 MikroORM Collection 类型。
 *
 * 注意：必须使用 `Collection<any>` 而非 `Collection<infer U>`，参考 `EntityDtoType` 的实现。
 * `Collection` 含有两个泛型参数（T、O），`infer U` 在条件类型中可能因 TypeScript
 * 泛型推断限制而匹配失败。
 *
 * @typeParam T - 待判断的类型
 */
type IsMikroOrmCollection<T> = T extends Collection<any> ? true : false;
/**
 * 处理 MikroORM Collection 属性 —— 应用集合量化操作符。
 *
 * @typeParam T - Collection 类型
 */
type ResolveCollectionOperator<T> = T extends Collection<infer U> ? ICollectionOperator<U> : never;
/**
 * 处理 MikroORM Ref 属性 —— 应用标量操作符于主键类型。
 *
 * @typeParam T - Ref 类型
 */
type ResolveRefOperator<T> = T extends Ref<infer U> ? IScalarOperator<Primary<U>> : never;
/**
 * 处理标量属性 —— 应用标量比较操作符。
 *
 * @typeParam T - 标量值类型
 */
type ResolveScalarOperator<T> = IScalarOperator<T>;
/**
 * 处理数组属性 —— 通过 {@link INestedOperator} 走集合操作符。
 *
 * @typeParam T - 数组类型
 */
type ResolveArrayOperator<T> = INestedOperator<T>;
/**
 * 处理嵌套实体属性（兜底） —— 递归映射所有属性。
 *
 * @typeParam T - 实体类型
 */
type ResolveObjectOperator<T> = IObjectOperator<T>;
/**
 * 根据属性类型推导对应的 filter 操作符集合。
 *
 * 分发优先级（从上到下，命中即停止）：
 * 1. MikroORM Collection → 集合量化操作符（$some/$every/$none）
 * 2. MikroORM Ref        → 标量比较操作符（作用于主键类型）
 * 3. 标量类型            → 标量比较操作符（$eq/$ne/$lt 等）
 * 4. 数组类型            → 通过 {@link INestedOperator} 走集合操作符
 * 5. 嵌套实体（兜底）     → 递归映射所有属性
 *
 * @typeParam T - 待分发的属性类型
 */
type IPropertyOperator<T> = IsMikroOrmCollection<T> extends true ? ResolveCollectionOperator<T> : T extends Ref<any> ? ResolveRefOperator<T> : IsMikroOrmScalar<T> extends true ? ResolveScalarOperator<T> : [T] extends [unknown[]] ? ResolveArrayOperator<T> : ResolveObjectOperator<T>;
/**
 * 实体属性的递归映射类型。将实体的每个属性映射为对应的 filter 操作符类型。
 *
 * @typeParam T - 实体类型
 */
type IObjectOperator<T> = { [K in keyof T as K extends string ? K : never]: IPropertyOperator<Exclude<T[K], undefined>> };
/**
 * 实体的 filter 类型。
 *
 * `undefined` 表示无过滤条件（不过滤）。
 *
 * @typeParam T - 实体类型
 */
type IFilter<T> = IObjectOperator<T> | undefined;
/**
 * 查询对象的 filter 包装。
 *
 * @typeParam T - 实体类型
 */
interface IFilterQuery<T> {
  /** 可选的 filter 条件 */
  filter?: IObjectOperator<T>;
}
//#endregion
//#region src/modules/core/pipes/filter-query-validation.pipe.d.ts
/**
 * FilterQuery 转换管道，负责将 HTTP 请求中的无前缀操作符（`eq`、`ne`）
 * 转换为内部的 `$eq`、`$ne` 格式，并对数据进行 class-validator 验证。
 *
 * 通常由 `@FilterQuery()` 装饰器内部使用。
 */
declare class FilterQueryTransformPipe<T> implements PipeTransform {
  private readonly FilterQueryClass;
  constructor(classRef: Class<T>);
  transform(value: unknown, metadata: ArgumentMetadata): Promise<IFilterQuery<T>>;
}
//#endregion
//#region src/modules/core/pipes/parse-uuidv7.pipe.d.ts
/**
 * UUIDv7 格式验证管道，校验输入字符串是否为合法的 UUIDv7。
 *
 * 若校验失败则抛出 `BadRequestException`。
 *
 * @example
 * ```typescript
 * @Controller('users')
 * class UserController {
 *   @Get(':id')
 *   findOne(@Param('id', ParseUUIDv7Pipe) id: string) {
 *     return this.userService.findOne(id)
 *   }
 * }
 * ```
 */
declare class ParseUUIDv7Pipe implements PipeTransform<string, string> {
  transform(value: string): string;
}
//#endregion
//#region src/modules/core/types/page-query.d.ts
type IOffsetPageParameters = {
  limit: number;
  offset: number;
};
type INextCursorPageParameters = {
  first: number; /** 首次加载无需传递 cursor */
  after?: string;
};
type IPreviousCursorPageParameters = {
  last: number;
  before?: string;
};
type IPageQuery<T extends 'cursor' | 'offset' = 'cursor' | 'offset'> = {
  page: T extends 'cursor' ? INextCursorPageParameters | IPreviousCursorPageParameters : T extends 'offset' ? IOffsetPageParameters : INextCursorPageParameters | IPreviousCursorPageParameters | IOffsetPageParameters;
};
//#endregion
//#region src/modules/core/models/offset-pagination.d.ts
declare class OffsetPagination {
  total: number;
  limit: number;
  offset: number;
  constructor(total: number, parameters: {
    limit: number;
    offset: number;
  });
}
//#endregion
//#region src/modules/core/models/cursor-pagination.d.ts
declare class CursorPagination {
  total?: number;
  limit: number;
  startCursor: string | null;
  endCursor: string | null;
  hasNextPage: boolean;
  hasPrevPage: boolean;
  constructor(cursor: Cursor<any>);
}
//#endregion
//#region src/modules/core/models/slice.d.ts
declare class Slice<T extends object> {
  data: Array<T>;
  pagination: OffsetPagination | CursorPagination;
  constructor(data: Array<T>, pagination: OffsetPagination | CursorPagination);
  [Symbol.iterator](): Iterator<T>;
  static fromOffset<T extends object>(data: Array<T>, total: number, parameters: IOffsetPageParameters): Slice<T>;
  static fromCursor<T extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(cursor: Cursor<T, Hint, Fields, Excludes>): Slice<Loaded<T, Hint, Fields, Excludes>>;
  map<R extends object>(fn: (item: T, index: number) => R): Slice<R>;
}
//#endregion
//#region src/modules/core/models/urn.d.ts
/**
 * 统一资源名称（URN）
 *
 * 格式: urn:buka:<domain>:<resource...>
 *
 * - 概念域级: urn:buka:galaxy
 * - 资源级: urn:buka:galaxy:auth-client:galaxy:console
 *
 * domain 之后的全部段为 resource 路径（: 分隔），parser 不区分"类型"和"实例"。
 * 应用层自行约定 resource 各段的语义。
 *
 * ```ts
 * Urn.of('galaxy')                                  // → 概念域级 URN
 * Urn.of('galaxy', 'auth-client:galaxy:console')     // → 资源级 URN
 * Urn.of('galaxy', ['auth-client', 'galaxy', 'console'])
 *
 * // 或通过派生方法构建
 * Urn.of('galaxy').withResource('auth-client', 'galaxy', 'console')
 * ```
 */
declare class Urn {
  /** 概念域 — 资源定义权归属，通常为系统名 */
  readonly domain: string;
  /** domain 之后的完整资源路径（: 分隔），undefined 表示概念域级 */
  readonly resource?: string | undefined;
  private constructor();
  /**
   * resource 按 `:` 拆分后的段数组
   */
  get resourceSegments(): string[];
  /**
   * 序列化为 URN 字符串
   */
  toString(): string;
  private toSegments;
  /**
   * 从概念域级 URN 衍生出资源级 URN
   *
   * @throws Error 当前 URN 已有 resource 时抛出
   */
  withResource(...segments: string[]): Urn;
  /**
   * 类型守卫：判断是否为概念域级 URN（无 resource）
   */
  isDomainUrn(): boolean;
  /**
   * 根据参数创建对应层级的 URN
   */
  static of(domain: string, resource?: string | string[]): Urn;
  /**
   * 从 URN 字符串解析，支持通配符 `*` 和 `**`
   *
   * - `*` 匹配恰好一个段
   * - `**` 匹配零个或多个尾部段（仅允许出现在末尾）
   *
   * @throws Error URN 格式不合法时抛出
   */
  static parse(urn: string): Urn;
  /**
   * 判断是否匹配指定的 domain 和 resource
   *
   * 未传入的参数不参与比较。
   */
  is(domain: string, resource?: string): boolean;
  /**
   * 判断当前 URN 是否匹配指定的 URN 模式（支持通配符）
   *
   * ```ts
   * urn.match('urn:buka:galaxy:principal:*')  // resource 以 principal: 开头
   * urn.match('urn:buka:galaxy:auth-client:**') // 任意深度的 auth-client
   * ```
   */
  match(pattern: string): boolean;
  /**
   * 判断当前 URN 是否包含另一个 URN
   *
   * 当前 URN 含通配符（`*` 或 `**`）时，作为集合模式判断：
   * - `*` 匹配恰好一个段
   * - `**` 匹配零个或多个尾部段（仅末尾有效）
   *
   * 当前 URN 为具体 URN（无通配符）时，仅包含自身（严格相等）。
   */
  contains(other: Urn): boolean;
}
//#endregion
//#region src/modules/core/converters/filter-query-type/decorators/filter-query-operators.decorator.d.ts
type FilterQueryOperator = 'eq' | 'ne' | 'lt' | 'gt' | 'lte' | 'gte' | 'in' | 'nin' | 'some' | 'every' | 'none';
declare const FilterQueryOperatorsMetadataKey = "buka:filter-query-operators";
/**
 * 指定属性在 `FilterQueryType` 中支持的过滤操作符。
 *
 * 如果未使用此装饰器，`FilterQueryType` 将使用默认操作符集合。
 *
 * @param operators - 允许的操作符数组
 *
 * @example
 * ```typescript
 * @Model()
 * class User {
 *   @FilterQueryOperators(['eq', 'ne', 'in'])
 *   @Property()
 *   status: string
 * }
 * ```
 */
declare function FilterQueryOperators(operators: FilterQueryOperator[]): PropertyDecorator;
declare function getFilterQueryOperators(target: object, propertyKey: string | symbol): readonly FilterQueryOperator[];
//#endregion
//#region src/modules/core/converters/pick-type/pick-type.d.ts
/**
 * 从模型中选取指定属性，生成新的子集类型。
 *
 * 类似 TypeScript 的 `Pick<T, K>`，同时保留 class-validator、class-transformer 和 Swagger 的元数据。
 *
 * @param classRef - 使用 `@Model()` 标注的类引用
 * @param keys - 需要选取的属性名数组
 * @returns 仅包含指定属性的新类
 *
 * @example
 * ```typescript
 * const CreateUserDTO = PickType(UserDTO, ['name', 'email'])
 * ```
 */
declare function PickType<T, K extends keyof T>(classRef: Class<T>, keys: K[]): Class<Pick<T, typeof keys[number]>>;
//#endregion
//#region src/modules/core/converters/omit-type/omit-type.d.ts
/**
 * 从模型中排除指定属性，生成新的类型。
 *
 * 类似 TypeScript 的 `Omit<T, K>`，同时保留 class-validator、class-transformer 和 Swagger 的元数据。
 *
 * @param classRef - 使用 `@Model()` 标注的类引用
 * @param keys - 需要排除的属性名数组
 * @returns 排除了指定属性的新类
 *
 * @example
 * ```typescript
 * const UpdateUserDTO = OmitType(UserDTO, ['id', 'createdAt'])
 * ```
 */
declare function OmitType<T, K extends keyof T>(classRef: Class<T>, keys: K[]): Class<Omit<T, typeof keys[number]>>;
//#endregion
//#region src/modules/core/converters/partial-type/partial-type.d.ts
/**
 * 将模型的所有属性变为可选，生成新的 Partial 类型。
 *
 * 类似 TypeScript 的 `Partial<T>`，同时保留 class-validator、class-transformer 和 Swagger 的元数据。
 *
 * @param classRef - 使用 `@Model()` 标注的类引用
 * @returns 所有属性均为可选的新类
 *
 * @example
 * ```typescript
 * const PatchUserDTO = PartialType(UserDTO)
 * ```
 */
declare function PartialType<T>(classRef: Class<T>): Class<Partial<T>>;
//#endregion
//#region src/modules/core/converters/intersection-type/intersection-type.d.ts
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type ClassRefsToConstructors<T extends Type[]> = { [U in keyof T]: T[U] extends Type<infer V> ? V : never };
type Intersection<T extends Type[]> = Type<UnionToIntersection<ClassRefsToConstructors<T>[number]>>;
/**
 * 将多个模型类合并为一个交叉类型。
 *
 * 类似 TypeScript 的交叉类型 `A & B`，同时合并 class-validator、class-transformer 和 Swagger 的元数据。
 *
 * @param classRefs - 需要合并的模型类引用列表
 * @returns 包含所有类属性的新类
 *
 * @example
 * ```typescript
 * const CreateUserDTO = IntersectionType(UserBaseDTO, UserProfileDTO)
 * ```
 */
declare function IntersectionType<T extends Type[]>(...classRefs: T): Intersection<T>;
//#endregion
//#region src/modules/core/converters/order-query-type/types/order-query.d.ts
interface IOrderQuery<T> {
  orderBy?: QueryOrderMap<T> | QueryOrderMap<T>[];
}
//#endregion
//#region src/modules/core/converters/order-query-type/order-query-type.d.ts
/**
 * 根据模型类自动生成排序查询 DTO 类型。
 *
 * 生成的类型包含 `orderBy` 属性，其值通过 JSON Schema 校验，确保只能按模型中的属性排序。
 *
 * @param classRef - 使用 `@Model()` 标注的类引用
 * @returns 包含 `orderBy` 属性的查询 DTO 类
 *
 * @example
 * ```typescript
 * @Model()
 * class User {
 *   @Property()
 *   name: string
 *
 *   @Property()
 *   createdAt: Date
 * }
 *
 * const UserOrderQuery = OrderQueryType(User)
 * // 允许按 name、createdAt 排序
 * ```
 */
declare function OrderQueryType<T>(classRef: Class<T>): Class<IOrderQuery<T>>;
//#endregion
//#region src/modules/core/converters/response-body-type/types/response-body-type.d.ts
interface IResponseBody<DATA> {
  data: DATA;
  meta: {
    [key: string]: any;
  };
}
//#endregion
//#region src/modules/core/converters/response-body-type/response-body-type.d.ts
type IResponseBodyClass<T> = Class<IResponseBody<T>> & {
  from(data: T): IResponseBody<T>;
};
/**
 * 生成标准响应体类型，将数据包裹在 `{ data: T }` 结构中。
 *
 * 返回的类包含 `from()` 静态方法和 `toJSON()` 序列化支持。
 *
 * @param classRef - 响应数据的模型类引用
 * @returns 包含 `data` 属性的响应体类
 *
 * @example
 * ```typescript
 * const UserResponse = ResponseBodyType(UserDTO)
 *
 * @Controller('users')
 * class UserController {
 *   @Get(':id')
 *   async findOne(@Param('id') id: string): Promise<UserResponse> {
 *     const user = await this.userService.findOne(id)
 *     return UserResponse.from(user)
 *   }
 * }
 * ```
 */
declare function ResponseBodyType<T extends object>(classRef: Class<T>): IResponseBodyClass<T>;
//#endregion
//#region src/modules/core/converters/list-response-body-type/types/list-response-body.d.ts
type IListResponseBodyMeta<MODE extends 'offset' | 'cursor' = 'offset' | 'cursor'> = {
  pagination: MODE extends 'cursor' ? CursorPagination : MODE extends 'offset' ? OffsetPagination : CursorPagination | OffsetPagination;
  [key: string]: any;
};
interface IListResponseBody<DATA, MODE extends 'offset' | 'cursor' = 'offset' | 'cursor'> extends IResponseBody<DATA[]> {
  meta: IListResponseBodyMeta<MODE>;
}
//#endregion
//#region src/modules/core/converters/list-response-body-type/list-response-body-type.d.ts
type IListResponseBodyClass<T extends object, MODE extends 'offset' | 'cursor'> = Class<IListResponseBody<T, MODE>> & {
  fromSlice(slice: Slice<T>): IListResponseBody<T, MODE>;
};
/**
 * 生成列表响应体类型，将数据包裹在 `{ data: T[], meta: { pagination } }` 结构中。
 *
 * 支持 offset 和 cursor 两种分页模式，通过 `fromSlice()` 静态方法从分页切片创建响应。
 *
 * @param classRef - 列表项的模型类引用
 * @param mode - 分页模式：`'offset'` 或 `'cursor'`，不传则同时支持两种
 * @returns 包含 `data` 和 `meta.pagination` 的列表响应体类
 *
 * @example
 * ```typescript
 * const UserListResponse = ListResponseBodyType(UserDTO, 'offset')
 *
 * @Controller('users')
 * class UserController {
 *   @Get()
 *   async findAll(@PageQuery('offset') page): Promise<UserListResponse> {
 *     const slice = await this.userService.findAll(page)
 *     return UserListResponse.fromSlice(slice)
 *   }
 * }
 * ```
 */
declare function ListResponseBodyType<T extends object, MODE extends 'offset' | 'cursor' = 'offset' | 'cursor'>(classRef: Type<T>, mode?: MODE): IListResponseBodyClass<T, MODE>;
//#endregion
//#region src/modules/mikro-orm/models/timestamped-entity.d.ts
declare abstract class TimestampedEntity<Optional = never> {
  [OptionalProps]?: 'createdAt' | 'updatedAt' | Optional;
  createdAt: Date;
  updatedAt: Date;
}
//#endregion
//#region src/modules/mikro-orm/models/linear-entity.d.ts
declare abstract class LinearEntity<Optional = never> extends TimestampedEntity<Optional> {
  [Config]?: DefineConfig<{
    forceObject: true;
  }>;
  [PrimaryKeyProp]?: 'id';
  id: string;
}
//#endregion
//#region src/modules/mikro-orm/models/discrete-entity.d.ts
declare abstract class DiscreteEntity<Optional = never> extends TimestampedEntity<Optional> {
  [Config]?: DefineConfig<{
    forceObject: true;
  }>;
  [PrimaryKeyProp]?: 'id';
  id: string;
}
//#endregion
//#region src/modules/mikro-orm/converters/entity-dto-type/entity-dto-type.d.ts
/**
 * 从实体中排除 `Collection` 类型的属性键。
 *
 * `Collection` 对应 OneToMany / ManyToMany 关系，默认 `lazy: true`，
 * 不应出现在 EntityDto 中。
 */
type IsCollection<T> = T extends Collection<any> ? true : false;
/**
 * 将实体的 MikroORM 类型转换为 DTO 友好的类型：
 * - `Collection<Entity>` → 键被排除（lazy，不在默认 Swagger 中）
 * - `Ref<Entity>` → **保留原样**（`Ref` 是 nestjs-kit 的一等公民类型，
 *   序列化层会自动处理：populated 时完整序列化，否则仅返回主键）
 * - `Xxx & Opt` → 去除 `Opt` 标记
 */
type EntityDtoShape<T> = { [K in keyof T as IsCollection<T[K]> extends true ? never : K]: ExcludeOpt<T[K]> };
/**
 * 基于实体生成一个无继承关系的纯 DTO 类，用于安全派生。
 *
 * 返回的类：
 * - 不继承实体类，避免 `Collection` 类型与 DTO 字段冲突
 * - 仅包含非 `lazy: true` 的 Model 属性
 * - 保留 `Ref<Entity>` 类型（序列化层自动处理：populated 时完整序列化，否则仅主键）
 * - 保留所有 Swagger、class-validator、class-transformer 元数据
 * - Swagger schema 与 `findOne()` 不加 populate 的结果一致
 *
 * @param classRef - 使用 `@Model()` 标注的实体类引用
 * @returns 可用于 `extends` 派生的纯 DTO 类
 *
 * @example
 * ```typescript
 * // 基本用法：派生不含 Collection 的 DTO
 * class UserProfileBriefDto extends EntityDto(UserProfile) {}
 *
 * // 扩展用法：手动添加 lazy 属性
 * class UserProfileDetailDto extends EntityDto(UserProfile) {
 *   @List({ type: () => PrimaryKeyType(Avatar) })
 *   avatars!: PrimaryKeyTypeClass[]
 * }
 * ```
 */
declare function EntityDto<T extends object>(classRef: Class<T>): Class<EntityDtoShape<T>>;
//#endregion
//#region src/modules/mikro-orm/converters/entity-primary-key-type/types/entity-primary-key.d.ts
type IEntityPrimaryKey<T extends object> = { [K in keyof T as K extends PrimaryProperty<T> ? K : never]: Primary<T> };
//#endregion
//#region src/modules/mikro-orm/converters/entity-primary-key-type/entity-primary-key-type.d.ts
declare const PrimaryKeyTypeClassMetadataPropertyKey: unique symbol;
declare function PrimaryKeyType<T extends object>(classRef: Class<T>): Class<IEntityPrimaryKey<T>>;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/varchar.column.d.ts
interface VarcharOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  length?: number;
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * VARCHAR 列装饰器，声明一个可变长度字符串列。
 *
 * 自动应用 MikroORM `@Property({ type: 'varchar' })`、`@IsString()` 验证及 Swagger schema。
 *
 * @param options - 列配置，支持 `length` 限制最大长度
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Varchar({ length: 255, comment: '用户名' })
 *   name: string
 * }
 * ```
 */
declare function Varchar<T extends object>(options?: VarcharOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/char.column.d.ts
interface CharOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  length?: number;
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * CHAR 列装饰器，声明一个固定长度字符串列。
 *
 * 自动应用 MikroORM `@Property({ type: 'char' })`、`@IsString()` 验证及 Swagger schema。
 * 当指定 `length` 时，同时校验最小和最大长度。
 *
 * @param options - 列配置，支持 `length` 指定固定长度
 *
 * @example
 * ```typescript
 * @Entity()
 * class Country {
 *   @Char({ length: 2, comment: '国家代码' })
 *   code: string
 * }
 * ```
 */
declare function Char<T extends object>(options?: CharOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/text.column.d.ts
interface TextOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * TEXT 列装饰器，声明一个无长度限制的文本列。
 *
 * 自动应用 MikroORM `@Property({ type: 'text' })`、`@IsString()` 验证及 Swagger schema。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class Article {
 *   @Text({ comment: '文章内容' })
 *   content: string
 * }
 * ```
 */
declare function Text<T extends object>(options?: TextOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/money.column.d.ts
interface MoneyOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * MONEY 列装饰器，声明一个货币类型列。
 *
 * 自动应用 MikroORM `@Property({ type: 'money' })`、`@IsCurrency()` 验证及 Swagger schema（format: money）。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class Order {
 *   @Money({ comment: '订单金额' })
 *   totalAmount: string
 * }
 * ```
 */
declare function Money<T extends object>(options?: MoneyOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/int.column.d.ts
interface IntOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * INT 列装饰器，声明一个 32 位整数列。
 *
 * 自动应用 MikroORM `@Property({ type: 'int' })`、`@IsInt()` 验证及 Swagger schema。
 *
 * @param options - 列配置，支持 `unsigned` 设置无符号
 *
 * @example
 * ```typescript
 * @Entity()
 * class Product {
 *   @Int({ unsigned: true, comment: '库存数量' })
 *   stock: number
 * }
 * ```
 */
declare function Int<T extends object>(options?: IntOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/smallint.column.d.ts
interface SmallintOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * SMALLINT 列装饰器，声明一个 16 位整数列。
 *
 * 自动应用 MikroORM `@Property({ type: 'smallint' })`、`@IsInt()` 验证及 Swagger schema。
 *
 * @param options - 列配置，支持 `unsigned` 设置无符号
 *
 * @example
 * ```typescript
 * @Entity()
 * class Config {
 *   @Smallint({ comment: '排序权重' })
 *   weight: number
 * }
 * ```
 */
declare function Smallint<T extends object>(options?: SmallintOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/tinyint.column.d.ts
interface TinyintOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * TINYINT 列装饰器，声明一个 8 位整数列。
 *
 * 自动应用 MikroORM `@Property({ type: 'tinyint' })`、`@IsInt()` 验证及 Swagger schema。
 *
 * @param options - 列配置，支持 `unsigned` 设置无符号
 *
 * @example
 * ```typescript
 * @Entity()
 * class Config {
 *   @Tinyint({ unsigned: true, comment: '状态码' })
 *   status: number
 * }
 * ```
 */
declare function Tinyint<T extends object>(options?: TinyintOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/bigint.column.d.ts
interface BigintOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  mode?: 'string' | 'number';
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * BIGINT 列装饰器，声明一个 64 位整数列。
 *
 * 默认以字符串模式（`mode: 'string'`）映射以避免 JavaScript 精度丢失，
 * 可设置 `mode: 'number'` 以数值模式映射。
 *
 * @param options - 列配置，支持 `mode` 切换映射模式
 *
 * @example
 * ```typescript
 * @Entity()
 * class Order {
 *   @Bigint({ comment: '订单号' })
 *   orderNo: string
 *
 *   @Bigint({ mode: 'number' })
 *   amount: number
 * }
 * ```
 */
declare function Bigint<T extends object>(options?: BigintOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/double.column.d.ts
interface DoubleOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * DOUBLE 列装饰器，声明一个双精度浮点数列。
 *
 * 自动应用 MikroORM `@Property({ type: 'double' })`、`@IsNumber()` 验证及 Swagger schema。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class Location {
 *   @Double({ comment: '经度' })
 *   longitude: number
 * }
 * ```
 */
declare function Double<T extends object>(options?: DoubleOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/numeric.column.d.ts
interface NumericOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * NUMERIC 列装饰器，声明一个精确数值列，适用于需要精确小数的场景（如金额计算）。
 *
 * 自动应用 MikroORM `@Property({ type: 'numeric' })`、`@IsNumber()` 验证及 Swagger schema。
 * 可通过 `precision` 和 `scale` 控制精度。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class Product {
 *   @Numeric({ precision: 10, scale: 2, comment: '价格' })
 *   price: number
 * }
 * ```
 */
declare function Numeric<T extends object>(options?: NumericOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/boolean.column.d.ts
interface BooleanOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * BOOLEAN 列装饰器，声明一个布尔类型列。
 *
 * 自动应用 MikroORM `@Property({ type: 'boolean' })`、`@IsBoolean()` 验证及 Swagger schema。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Boolean({ comment: '是否激活' })
 *   isActive: boolean
 * }
 * ```
 */
declare function Boolean$1<T extends object>(options?: BooleanOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/uuid.column.d.ts
interface UuidOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * UUID 列装饰器，声明一个 UUID 类型列。
 *
 * 自动应用 MikroORM `@Property({ type: 'uuid' })`、`@IsString()` 验证及 Swagger schema（format: uuid）。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Uuid({ comment: '用户 ID' })
 *   id: string
 * }
 * ```
 */
declare function Uuid<T extends object>(options?: UuidOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/timestamptz.column.d.ts
interface TimestamptzOptions<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * TIMESTAMPTZ 列装饰器，声明一个带时区的时间戳列。
 *
 * 自动应用 MikroORM `@Property({ type: 'timestamptz' })`、`@IsISO8601()` 验证及 Swagger schema（format: date-time）。
 *
 * @param options - 列配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Timestamptz({ comment: '创建时间' })
 *   createdAt: string
 * }
 * ```
 */
declare function Timestamptz<T extends object>(options?: TimestamptzOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/enum.column.d.ts
interface ColumnEnumOptions extends Omit<EnumOptions<AnyEntity>, 'type' | 'columnType'> {
  enumName?: string;
  example?: SchemaObject['example'];
  examples?: SchemaObject['examples'];
}
/**
 * 枚举列装饰器，声明一个枚举类型的数据库列。
 *
 * 自动应用 MikroORM `@Enum()` 及 Swagger schema，支持通过 `items` 指定枚举值。
 *
 * @param options - 列配置，必须通过 `items` 指定枚举值数组或返回枚举值的函数
 *
 * @example
 * ```typescript
 * enum Status { Active = 'active', Inactive = 'inactive' }
 *
 * @Entity()
 * class User {
 *   @Enum({ items: () => Status, enumName: 'Status', comment: '用户状态' })
 *   status: Status
 * }
 * ```
 */
declare function Enum$1<T extends object>(options: ColumnEnumOptions): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/jsonb.column.d.ts
interface JsonbOptionsBase<T extends object> extends Omit<PropertyOptions<T>, 'type' | 'columnType'> {
  schema?: ApiPropertyOptions;
}
/**
 * kind = 'composite'（默认）时，type 必须是 class 引用，不能是标量类型。
 */
interface JsonbOptionsComposite<T extends object> extends JsonbOptionsBase<T> {
  type: () => Class<object>;
  kind?: 'composite';
}
/**
 * kind = 'list' | 'dictionary' 时，type 可以是 class 引用或标量类型（String / Number / Boolean）。
 */
interface JsonbOptionsListOrDict<T extends object> extends JsonbOptionsBase<T> {
  type: (() => Class<object>) | ScalarClass;
  kind: 'list' | 'dictionary';
}
type JsonbOptions<T extends object> = JsonbOptionsComposite<T> | JsonbOptionsListOrDict<T>;
/**
 * JSONB 列装饰器，声明一个 JSONB 类型的数据库列。
 *
 * 通过 `kind` 参数指定 JSON 数据的结构类型：`'composite'`（对象）、`'list'`（数组）或 `'dictionary'`（字典），
 * 自动应用对应的 `@Composite()`、`@List()` 或 `@Dictionary()` 装饰器。
 *
 * @param options - 列配置，必须通过 `type` 指定嵌套类引用
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Jsonb({ type: () => ProfileDTO, comment: '用户资料' })
 *   profile: ProfileDTO
 *
 *   @Jsonb({ type: () => TagDTO, kind: 'list', comment: '标签列表' })
 *   tags: TagDTO[]
 * }
 * ```
 */
declare function Jsonb<T extends object>(options: JsonbOptions<T>): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/transient.column.d.ts
interface TransientOptions {
  type: string;
}
/**
 * 瞬态属性装饰器，标记属性不持久化到数据库。
 *
 * 等效于 MikroORM `@Property({ persist: false })`，适用于仅在运行时使用的计算属性。
 * 同时向 ModelRegister 注册，以便类型系统正确识别该属性。
 *
 * @param options - 必须通过 `type` 指定属性类型（MikroORM v7 要求）
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Transient({ type: 'string' })
 *   fullName: string
 * }
 * ```
 */
declare function Transient<T extends object>(options: TransientOptions): (target: T, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/embedded.column.d.ts
/**
 * Embedded 列装饰器，声明一个嵌入式（Embeddable）对象列。
 *
 * 将嵌入对象的属性平铺到父实体的表中。支持单个嵌入对象和嵌入数组（`array: true`）。
 *
 * @param type - 嵌入类型的引用函数，或包含配置的 options 对象
 * @param options - 可选的 MikroORM Embedded 配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @Embedded(() => Address)
 *   address: Address
 *
 *   @Embedded(() => Phone, { array: true })
 *   phones: Phone[]
 * }
 * ```
 */
declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/columns/index.d.ts
declare const Column: {
  readonly Varchar: typeof Varchar;
  readonly Char: typeof Char;
  readonly Text: typeof Text;
  readonly Money: typeof Money;
  readonly Int: typeof Int;
  readonly Smallint: typeof Smallint;
  readonly Tinyint: typeof Tinyint;
  readonly Bigint: typeof Bigint;
  readonly Double: typeof Double;
  readonly Numeric: typeof Numeric;
  readonly Boolean: typeof Boolean$1;
  readonly Uuid: typeof Uuid;
  readonly Timestamptz: typeof Timestamptz;
  readonly Enum: typeof Enum$1;
  readonly Jsonb: typeof Jsonb;
  readonly Transient: typeof Transient;
  readonly Embedded: typeof Embedded;
};
//#endregion
//#region src/modules/mikro-orm/decorators/cardinality/many-to-one.cardinality.d.ts
/**
 * 多对一关系装饰器，封装 MikroORM `@ManyToOne()` 并自动注册 `@Composite()` 元数据和 Swagger schema。
 *
 * @example
 * ```typescript
 * @Entity()
 * class Post {
 *   @ManyToOne(() => User)
 *   author: User
 * }
 * ```
 */
declare function ManyToOne<Target extends object, Owner extends object>(entity?: ManyToOneOptions<Owner, Target> | ((e?: any) => EntityName<Target>), options?: Partial<ManyToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/cardinality/one-to-one.cardinality.d.ts
/**
 * 一对一关系装饰器，封装 MikroORM `@OneToOne()` 并自动注册 `@Composite()` 元数据和 Swagger schema。
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @OneToOne(() => Profile, (profile) => profile.user)
 *   profile: Profile
 * }
 * ```
 */
declare function OneToOne<Target extends object, Owner extends object>(entity?: OneToOneOptions<Owner, Target> | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: Owner, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/cardinality/one-to-many.cardinality.d.ts
/**
 * 一对多关系装饰器，封装 MikroORM `@OneToMany()` 并自动注册 `@List()` 元数据和 Swagger schema。
 *
 * @param options - MikroORM OneToMany 配置
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @OneToMany({ entity: () => Post, mappedBy: 'author' })
 *   posts: Collection<Post>
 * }
 * ```
 */
declare function OneToMany<Target extends object, Owner extends object>(options: OneToManyOptions<Owner, Target>): (target: Owner, propertyName: string) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/cardinality/many-to-many.cardinality.d.ts
/**
 * 多对多关系装饰器，封装 MikroORM `@ManyToMany()` 并自动注册 `@List()` 元数据和 Swagger schema。
 *
 * @example
 * ```typescript
 * @Entity()
 * class User {
 *   @ManyToMany(() => Role, (role) => role.users)
 *   roles: Collection<Role>
 * }
 * ```
 */
declare function ManyToMany<Target extends object, Owner extends object>(entity?: ManyToManyOptions<Owner, Target> | (() => EntityName<Target>), mappedBy?: (string & keyof Target) | ((e: Target) => any), options?: Partial<ManyToManyOptions<Owner, Target>>): (target: Owner, propertyName: string & keyof Owner) => void;
//#endregion
//#region src/modules/mikro-orm/decorators/cardinality/index.d.ts
declare const Cardinality: {
  readonly ManyToOne: typeof ManyToOne;
  readonly OneToOne: typeof OneToOne;
  readonly OneToMany: typeof OneToMany;
  readonly ManyToMany: typeof ManyToMany;
};
//#endregion
//#region src/modules/mikro-orm/decorators/entity-ref/entity-ref.decorator.d.ts
interface EntityRefOptions {
  optional?: boolean;
  schema?: ApiPropertyOptions;
  association?: RefAssociationMetadata;
}
/**
 * 实体引用装饰器，通过实体的主键类型声明对另一个实体的引用。
 *
 * 内部使用 `PrimaryKeyType()` 将实体类转换为仅包含主键字段的 DTO，
 * 适用于创建/更新请求中通过主键关联实体的场景。
 *
 * @param entity - 被引用实体的类引用函数
 * @param options - 可选配置
 *
 * @example
 * ```typescript
 * @Model()
 * class CreatePostDTO {
 *   @Property()
 *   title: string
 *
 *   @EntityRef(() => User)
 *   author: { id: string }
 * }
 * ```
 */
declare function EntityRef<T extends object>(entity: () => Class<T>, options?: EntityRefOptions): PropertyDecorator;
//#endregion
//#region src/modules/mikro-orm/database.config.d.ts
declare class DatabaseConfig {
  debug: boolean;
  migration: boolean;
  dbName: string;
  host: string;
  port: number;
  user: string;
  password: string;
  timezone?: string | undefined;
  poolMax: number;
  poolMin: number;
  poolIdleTimeoutMillis: number;
  toMikroOrmOptions(config?: Partial<Options>): Partial<Options>;
}
//#endregion
//#region src/modules/mikro-orm/types/exclude-opt.d.ts
type ExcludeDefinedOpt<T> = T extends infer E & Opt ? E : T;
type ExcludeOpt<T> = ExcludeDefinedOpt<Exclude<T, undefined>>;
//#endregion
//#region src/modules/mikro-orm/types/exclude-ref.d.ts
type ExcludeRef<T> = T extends Ref<infer U> ? U : T;
//#endregion
//#region src/modules/mikro-orm/types/exclude-hidden.d.ts
type ExcludeHidden<T> = T extends infer U & Hidden ? U : T;
//#endregion
//#region src/modules/mikro-orm/types/is-opt.d.ts
type IsOpt<T> = typeof Opt['__optional'] extends keyof T ? true : false;
//#endregion
//#region src/modules/mikro-orm/types/is-hidden.d.ts
type IsHidden<T> = typeof Hidden['__hidden'] extends keyof T ? true : false;
//#endregion
//#region src/modules/open-bao/types/open-bao-auth.types.d.ts
/**
 * 直接使用 Token 进行认证
 */
interface OpenBaoTokenAuth {
  method: 'token';
  /** OpenBao 认证令牌 */
  token: string;
}
/**
 * 使用用户名密码进行认证
 */
interface OpenBaoUserpassAuth {
  method: 'userpass';
  /** 用户名 */
  username: string;
  /** 密码 */
  password: string;
  /** 认证引擎挂载路径，默认 'userpass' */
  mount?: string;
}
/**
 * 使用 AppRole 进行认证
 */
interface OpenBaoAppRoleAuth {
  method: 'approle';
  /** AppRole 的 Role ID */
  roleId: string;
  /** AppRole 的 Secret ID */
  secretId: string;
  /** 认证引擎挂载路径，默认 'approle' */
  mount?: string;
}
/**
 * 使用 Kubernetes ServiceAccount 进行认证
 */
interface OpenBaoKubernetesAuth {
  method: 'kubernetes';
  /** Kubernetes 角色名称 */
  role: string;
  /** JWT 令牌，如不提供则从 tokenPath 读取 */
  jwt?: string;
  /** ServiceAccount Token 文件路径，默认 '/var/run/secrets/kubernetes.io/serviceaccount/token' */
  tokenPath?: string;
  /** 认证引擎挂载路径，默认 'kubernetes' */
  mount?: string;
}
/**
 * OpenBao 认证方式联合类型
 */
type OpenBaoAuthMethod = OpenBaoTokenAuth | OpenBaoUserpassAuth | OpenBaoAppRoleAuth | OpenBaoKubernetesAuth;
/**
 * OpenBao 认证响应（Vault/OpenBao 登录 API 的通用返回结构）
 */
interface OpenBaoAuthResponse {
  auth: {
    client_token: string;
    accessor: string;
    policies: string[];
    token_policies: string[];
    metadata: Record<string, string>;
    lease_duration: number;
    renewable: boolean;
  };
}
/**
 * OpenBao Token Lookup Self 响应
 */
interface OpenBaoTokenLookupSelfResponse {
  data: {
    accessor?: string;
    creation_time?: number;
    creation_ttl?: number;
    display_name?: string;
    entity_id?: string;
    expire_time?: string;
    explicit_max_ttl?: number;
    id?: string;
    issue_time?: string;
    last_renewal?: string;
    last_renewal_time?: number;
    meta?: Record<string, string>;
    num_uses?: number;
    orphan?: boolean;
    path?: string;
    period?: number;
    policies?: string[];
    renewable?: boolean;
    ttl?: number;
    type?: string;
  };
}
//#endregion
//#region src/modules/open-bao/types/open-bao-module-options.d.ts
interface OpenBaoModuleOptions {
  /**
   * OpenBao 服务器地址
   */
  address: string;
  /**
   * 身份认证配置
   */
  auth: OpenBaoAuthMethod;
  /**
   * Transit 引擎挂载路径，默认 'transit'
   */
  transitMount?: string;
  /**
   * Token 续期提前量（秒），在 Token 过期前多少秒触发续期，默认 30
   */
  renewBufferSeconds?: number;
}
//#endregion
//#region src/modules/open-bao/open-bao-token.manager.d.ts
/**
 * OpenBao Token 生命周期管理服务
 *
 * 负责：
 * - 通过配置的认证方式获取 Token
 * - 定时续期 Token（在 Token 过期前触发）
 * - 续期失败时自动重新认证
 */
declare class OpenBaoTokenManager implements OnModuleInit, OnModuleDestroy {
  private readonly config;
  private readonly logger;
  /**
   * 用于认证操作的独立 KeqRequest 实例（不依赖动态 token 中间件）
   */
  private readonly authRequest;
  private token;
  private renewable;
  private leaseDuration;
  private renewalTimer;
  constructor(config: OpenBaoModuleOptions);
  onModuleInit(): Promise<void>;
  onModuleDestroy(): void;
  /**
   * 获取当前有效的 Token
   * @throws 如果 Token 尚未获取或认证失败
   */
  getToken(): string;
  private authenticate;
  /**
   * 使用用户名密码登录
   */
  private loginUserpass;
  /**
   * 使用 AppRole 登录
   */
  private loginAppRole;
  /**
   * 使用 Kubernetes ServiceAccount 登录
   */
  private loginKubernetes;
  /**
   * 处理认证响应，提取 Token 和续期信息
   */
  private handleAuthResponse;
  /**
   * 查询当前 Token 的信息（用于 token 认证方式，获取 TTL 和续期能力）
   */
  private lookupTokenInfo;
  /**
   * 根据 Token 的 TTL 和续期缓冲时间，调度下一次续期
   */
  private scheduleRenewal;
  /**
   * 执行 Token 续期，失败时尝试重新认证
   */
  private renewToken;
}
//#endregion
//#region src/apis/open-bao-http/open-bao-http.module.d.ts
interface OpenBaoHttpModuleOptions extends KeqModuleOptions {
  /**
   * Whether to register the module globally.
   * @default false
   */
  isGlobal?: boolean;
}
declare const ConfigurableModuleClass$4: _$_nestjs_common0.ConfigurableModuleCls<OpenBaoHttpModuleOptions, "register", "create", {
  isGlobal: boolean;
}>;
/**
 * NestJS module that provides the {@link OpenBaoHttpClient} for dependency injection.
 *
 * This module requires a `KeqRequest` instance, which can be provided in two ways:
 *
 * **Option 1: Use the global `KeqModule` (recommended)**
 *
 * Import `KeqModule` globally, then register this module.
 * The module will fork from the global KeqRequest and inherit its middlewares.
 *
 * ```typescript
 * // app.module.ts
 * import { KeqModule } from '@keq-request/nestjs'
 *
 * @Module({
 *   imports: [
 *     KeqModule,
 *     OpenBaoHttpModule.register({
 *       isGlobal: true, // optional, default false
 *       middlewares: [], // module-level middlewares
 *     }),
 *   ],
 * })
 * export class AppModule {}
 * ```
 *
 * **Option 2: Provide an isolated `KeqRequest` instance**
 *
 * ```typescript
 * @Module({
 *   imports: [
 *     OpenBaoHttpModule.register({
 *       isolate: true, // no inherited middlewares
 *     }),
 *   ],
 * })
 * export class SomeFeatureModule {}
 * ```
 *
 * Then inject `OpenBaoHttpClient` in your services:
 *
 * ```typescript
 * @Injectable()
 * export class SomeService {
 *   constructor(private readonly client: OpenBaoHttpClient) {}
 * }
 * ```
 */
declare class OpenBaoHttpModule extends ConfigurableModuleClass$4 {
  static readonly KEQ_REQUEST: symbol;
  static readonly KEQ_CONSUMER: symbol;
}
//#endregion
//#region src/modules/open-bao/open-bao.module-definition.d.ts
declare const ConfigurableModuleClass$3: _$_nestjs_common0.ConfigurableModuleCls<OpenBaoModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
//#endregion
//#region src/modules/open-bao/open-bao.module.d.ts
/**
 * OpenBao 核心模块
 *
 * 通过配置的身份认证方式（Token / Userpass / AppRole / Kubernetes）
 * 获取并维持 OpenBao Token，为 OpenBaoHttpClient 提供认证能力。
 *
 * 使用前需在根模块中导入 `KeqModule`：
 *
 * ```ts
 * import { KeqModule } from '@keq-request/nestjs'
 *
 * @Module({
 *   imports: [
 *     KeqModule,
 *     OpenBaoModule.register({
 *       address: 'http://localhost:8200',
 *       auth: { method: 'token', token: 's.xxxxx' },
 *     }),
 *   ],
 * })
 * export class AppModule {}
 * ```
 *
 * @example
 * ```ts
 * // Token 认证
 * OpenBaoModule.register({
 *   address: 'http://localhost:8200',
 *   auth: { method: 'token', token: 's.xxxxx' },
 * })
 *
 * // Userpass 认证
 * OpenBaoModule.register({
 *   address: 'http://localhost:8200',
 *   auth: { method: 'userpass', username: 'admin', password: 'secret' },
 * })
 *
 * // AppRole 认证
 * OpenBaoModule.register({
 *   address: 'http://localhost:8200',
 *   auth: { method: 'approle', roleId: 'xxx', secretId: 'yyy' },
 * })
 *
 * // Kubernetes 认证
 * OpenBaoModule.register({
 *   address: 'http://localhost:8200',
 *   auth: { method: 'kubernetes', role: 'my-role' },
 * })
 * ```
 */
declare class OpenBaoModule extends ConfigurableModuleClass$3 {
  private readonly options;
  private readonly tokenManager;
  constructor(options: OpenBaoModuleOptions, tokenManager: OpenBaoTokenManager, consumer: KeqConsumer<typeof OpenBaoHttpModule>);
}
//#endregion
//#region src/modules/open-bao/open-bao.config.d.ts
declare class OpenBaoTokenAuthConfig implements OpenBaoTokenAuth {
  method: "token";
  token: string;
}
declare class OpenBaoUserpassAuthConfig implements OpenBaoUserpassAuth {
  method: "userpass";
  username: string;
  password: string;
  mount?: string;
}
declare class OpenBaoAppRoleAuthConfig implements OpenBaoAppRoleAuth {
  method: "approle";
  roleId: string;
  secretId: string;
  mount?: string;
}
declare class OpenBaoKubernetesAuthConfig implements OpenBaoKubernetesAuth {
  method: "kubernetes";
  role: string;
  jwt?: string;
  tokenPath?: string;
  mount?: string;
}
declare class OpenBaoModuleConfig implements OpenBaoModuleOptions {
  /**
   * OpenBao 服务器地址
   */
  address: string;
  /**
   * 身份认证配置
   */
  auth: OpenBaoAuthMethod;
  /**
   * Transit 引擎挂载路径
   */
  transitMount?: string;
  /**
   * Token 续期提前量（秒）
   */
  renewBufferSeconds?: number;
}
//#endregion
//#region src/modules/open-bao/set-open-bao-token.middleware.d.ts
/**
 * Create OpenBao Token middleware
 *
 * Automatically adds `X-Vault-Token` header to requests, excluding unauthenticated endpoints.
 *
 * @param getToken Callback function to get the current valid token
 * @returns keq middleware
 *
 * @example
 * ```ts
 * const request = new KeqRequest()
 * request.use(setOpenBaoToken(() => tokenManager.getToken()))
 * ```
 */
declare function setOpenBaoToken(getToken: () => string): KeqMiddleware;
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-read-auth-configuration.type.d.ts
interface KubernetesReadAuthConfigurationResponseBodies {
  200: void;
}
type KubernetesReadAuthConfigurationRequestQuery = {};
type KubernetesReadAuthConfigurationRouteParameters = {};
type KubernetesReadAuthConfigurationRequestHeaders = {};
type KubernetesReadAuthConfigurationRequestParameters = KubernetesReadAuthConfigurationRequestQuery & KubernetesReadAuthConfigurationRouteParameters & KubernetesReadAuthConfigurationRequestHeaders;
interface KubernetesReadAuthConfigurationOperation<STATUS extends keyof KubernetesReadAuthConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KubernetesReadAuthConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesReadAuthConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesReadAuthConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KubernetesReadAuthConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kubernetes-configure-auth-request.schema.d.ts
interface KubernetesConfigureAuthRequest {
  /**
   * Disable JWT issuer validation (Deprecated, will be removed in a future release)
   * @deprecated
   */
  disable_iss_validation?: boolean;
  /**
   * Disable defaulting to the local CA cert and service account JWT when running in a Kubernetes pod
   */
  disable_local_ca_jwt?: boolean;
  /**
   * Optional JWT issuer. If no issuer is specified, then this plugin will use kubernetes.io/serviceaccount as the default issuer. (Deprecated, will be removed in a future release)
   * @deprecated
   */
  issuer?: string;
  /**
   * PEM encoded CA cert for use by the TLS client used to talk with the API.
   */
  kubernetes_ca_cert?: string;
  /**
   * Host must be a host string, a host:port pair, or a URL to the base of the Kubernetes API server.
   */
  kubernetes_host?: string;
  /**
   * Optional list of PEM-formated public keys or certificates used to verify the signatures of kubernetes service account JWTs. If a certificate is given, its public key will be extracted. Not every installation of Kubernetes exposes these keys.
   */
  pem_keys?: string[];
  /**
   * A service account JWT (or other token) used as a bearer token to access the TokenReview API to validate other JWTs during login. If not set the JWT used for login will be used to access the API.
   */
  token_reviewer_jwt?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-configure-auth.type.d.ts
interface KubernetesConfigureAuthResponseBodies {
  200: void;
}
interface KubernetesConfigureAuthRequestBodies {
  'application/json': KubernetesConfigureAuthRequest;
}
type KubernetesConfigureAuthRequestQuery = {};
type KubernetesConfigureAuthRouteParameters = {};
type KubernetesConfigureAuthRequestHeaders = {};
interface KubernetesConfigureAuthParameterBodies {
  'application/json': KubernetesConfigureAuthRequest & {
    [key: string]: any;
  };
}
type KubernetesConfigureAuthRequestParameters = KubernetesConfigureAuthRequestQuery & KubernetesConfigureAuthRouteParameters & KubernetesConfigureAuthRequestHeaders & KubernetesConfigureAuthRequestBodies['application/json'];
interface KubernetesConfigureAuthOperation<STATUS extends keyof KubernetesConfigureAuthResponseBodies, CONTENT_TYPE extends keyof KubernetesConfigureAuthParameterBodies> extends KeqOperation {
  requestParams: KubernetesConfigureAuthRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesConfigureAuthRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesConfigureAuthRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KubernetesConfigureAuthParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KubernetesConfigureAuthResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kubernetes-login-request.schema.d.ts
interface KubernetesLoginRequest {
  /**
   * A signed JWT for authenticating a service account. This field is required.
   */
  jwt?: string;
  /**
   * Name of the role against which the login is being attempted. This field is required
   */
  role?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-login.type.d.ts
interface KubernetesLoginResponseBodies {
  200: void;
}
interface KubernetesLoginRequestBodies {
  'application/json': KubernetesLoginRequest;
}
type KubernetesLoginRequestQuery = {};
type KubernetesLoginRouteParameters = {};
type KubernetesLoginRequestHeaders = {};
interface KubernetesLoginParameterBodies {
  'application/json': KubernetesLoginRequest & {
    [key: string]: any;
  };
}
type KubernetesLoginRequestParameters = KubernetesLoginRequestQuery & KubernetesLoginRouteParameters & KubernetesLoginRequestHeaders & KubernetesLoginRequestBodies['application/json'];
interface KubernetesLoginOperation<STATUS extends keyof KubernetesLoginResponseBodies, CONTENT_TYPE extends keyof KubernetesLoginParameterBodies> extends KeqOperation {
  requestParams: KubernetesLoginRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesLoginRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesLoginRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KubernetesLoginParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KubernetesLoginResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-list-auth-roles.type.d.ts
interface KubernetesListAuthRolesResponseBodies {
  200: void;
}
type KubernetesListAuthRolesRequestQuery = {
  list: ('true');
};
type KubernetesListAuthRolesRouteParameters = {};
type KubernetesListAuthRolesRequestHeaders = {};
type KubernetesListAuthRolesRequestParameters = KubernetesListAuthRolesRequestQuery & KubernetesListAuthRolesRouteParameters & KubernetesListAuthRolesRequestHeaders;
interface KubernetesListAuthRolesOperation<STATUS extends keyof KubernetesListAuthRolesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KubernetesListAuthRolesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesListAuthRolesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesListAuthRolesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KubernetesListAuthRolesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-read-auth-role.type.d.ts
interface KubernetesReadAuthRoleResponseBodies {
  200: void;
}
type KubernetesReadAuthRoleRequestQuery = {};
type KubernetesReadAuthRoleRouteParameters = {};
type KubernetesReadAuthRoleRequestHeaders = {};
type KubernetesReadAuthRoleRequestParameters = KubernetesReadAuthRoleRequestQuery & KubernetesReadAuthRoleRouteParameters & KubernetesReadAuthRoleRequestHeaders;
interface KubernetesReadAuthRoleOperation<STATUS extends keyof KubernetesReadAuthRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KubernetesReadAuthRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesReadAuthRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesReadAuthRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KubernetesReadAuthRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kubernetes-write-auth-role-request.schema.d.ts
interface KubernetesWriteAuthRoleRequest {
  /**
   * Source to use when deriving the Alias name. valid choices: "serviceaccount_uid" : <token.uid> e.g. 474b11b5-0f20-4f9d-8ca5-65715ab325e0 (most secure choice) "serviceaccount_name" : <namespace>/<serviceaccount> e.g. vault/vault-agent default: "serviceaccount_uid"
   */
  alias_name_source?: string;
  /**
   * Optional Audience claim to verify in the jwt.
   */
  audience?: string;
  /**
   * Use "token_bound_cidrs" instead. If this and "token_bound_cidrs" are both specified, only "token_bound_cidrs" will be used.
   * @deprecated
   */
  bound_cidrs?: string[];
  /**
   * List of service account names able to access this role. If set to "*" all names are allowed.
   */
  bound_service_account_names?: string[];
  /**
   * A label selector for Kubernetes namespaces which are allowed to access this role. Accepts either a JSON or YAML object. If set with bound_service_account_namespaces, the conditions are ORed.
   */
  bound_service_account_namespace_selector?: string;
  /**
   * List of namespaces allowed to access this role. If set to "*" all namespaces are allowed.
   */
  bound_service_account_namespaces?: string[];
  /**
   * Use "token_max_ttl" instead. If this and "token_max_ttl" are both specified, only "token_max_ttl" will be used.
   * @deprecated
   * @format seconds
   */
  max_ttl?: number;
  /**
   * Use "token_num_uses" instead. If this and "token_num_uses" are both specified, only "token_num_uses" will be used.
   * @deprecated
   */
  num_uses?: number;
  /**
   * Use "token_period" instead. If this and "token_period" are both specified, only "token_period" will be used.
   * @deprecated
   * @format seconds
   */
  period?: number;
  /**
   * Use "token_policies" instead. If this and "token_policies" are both specified, only "token_policies" will be used.
   * @deprecated
   */
  policies?: string[];
  /**
   * Comma separated string or JSON list of CIDR blocks. If set, specifies the blocks of IP addresses which are allowed to use the generated token.
   */
  token_bound_cidrs?: string[];
  /**
   * If set, tokens created via this role carry an explicit maximum TTL. During renewal, the current maximum TTL values of the role and the mount are not checked for changes, and any updates to these values will have no effect on the token being renewed.
   * @format seconds
   */
  token_explicit_max_ttl?: number;
  /**
   * The maximum lifetime of the generated token
   * @format seconds
   */
  token_max_ttl?: number;
  /**
   * If true, the 'default' policy will not automatically be added to generated tokens
   */
  token_no_default_policy?: boolean;
  /**
   * The maximum number of times a token may be used, a value of zero means unlimited
   */
  token_num_uses?: number;
  /**
   * If set, tokens created via this role will have no max lifetime; instead, their renewal period will be fixed to this value. This takes an integer number of seconds, or a string duration (e.g. "24h").
   * @format seconds
   */
  token_period?: number;
  /**
   * Comma-separated list of policies
   */
  token_policies?: string[];
  /**
   * If true, CIDRs for the token will be strictly bound to the source IP address of the login request
   */
  token_strictly_bind_ip?: boolean;
  /**
   * The initial ttl of the token to generate
   * @format seconds
   */
  token_ttl?: number;
  /**
   * The type of token to generate, service or batch
   */
  token_type?: string;
  /**
   * Use "token_ttl" instead. If this and "token_ttl" are both specified, only "token_ttl" will be used.
   * @deprecated
   * @format seconds
   */
  ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-write-auth-role.type.d.ts
interface KubernetesWriteAuthRoleResponseBodies {
  200: void;
}
interface KubernetesWriteAuthRoleRequestBodies {
  'application/json': KubernetesWriteAuthRoleRequest;
}
type KubernetesWriteAuthRoleRequestQuery = {};
type KubernetesWriteAuthRoleRouteParameters = {};
type KubernetesWriteAuthRoleRequestHeaders = {};
interface KubernetesWriteAuthRoleParameterBodies {
  'application/json': KubernetesWriteAuthRoleRequest & {
    [key: string]: any;
  };
}
type KubernetesWriteAuthRoleRequestParameters = KubernetesWriteAuthRoleRequestQuery & KubernetesWriteAuthRoleRouteParameters & KubernetesWriteAuthRoleRequestHeaders & KubernetesWriteAuthRoleRequestBodies['application/json'];
interface KubernetesWriteAuthRoleOperation<STATUS extends keyof KubernetesWriteAuthRoleResponseBodies, CONTENT_TYPE extends keyof KubernetesWriteAuthRoleParameterBodies> extends KeqOperation {
  requestParams: KubernetesWriteAuthRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesWriteAuthRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesWriteAuthRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KubernetesWriteAuthRoleParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KubernetesWriteAuthRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kubernetes-delete-auth-role.type.d.ts
interface KubernetesDeleteAuthRoleResponseBodies {
  204: void;
}
type KubernetesDeleteAuthRoleRequestQuery = {};
type KubernetesDeleteAuthRoleRouteParameters = {};
type KubernetesDeleteAuthRoleRequestHeaders = {};
type KubernetesDeleteAuthRoleRequestParameters = KubernetesDeleteAuthRoleRequestQuery & KubernetesDeleteAuthRoleRouteParameters & KubernetesDeleteAuthRoleRequestHeaders;
interface KubernetesDeleteAuthRoleOperation<STATUS extends keyof KubernetesDeleteAuthRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KubernetesDeleteAuthRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KubernetesDeleteAuthRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KubernetesDeleteAuthRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KubernetesDeleteAuthRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-list-accessors.type.d.ts
interface TokenListAccessorsResponseBodies {
  200: void;
}
type TokenListAccessorsRequestQuery = {
  list: ('true');
};
type TokenListAccessorsRouteParameters = {};
type TokenListAccessorsRequestHeaders = {};
type TokenListAccessorsRequestParameters = TokenListAccessorsRequestQuery & TokenListAccessorsRouteParameters & TokenListAccessorsRequestHeaders;
interface TokenListAccessorsOperation<STATUS extends keyof TokenListAccessorsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenListAccessorsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenListAccessorsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenListAccessorsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenListAccessorsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-create-request.schema.d.ts
interface TokenCreateRequest {
  /**
   * Name to associate with this token
   */
  display_name?: string;
  /**
   * Name of the entity alias to associate with this token
   */
  entity_alias?: string;
  /**
   * Explicit Max TTL of this token
   */
  explicit_max_ttl?: string;
  /**
   * Value for the token
   */
  id?: string;
  /**
   * Use 'ttl' instead
   * @deprecated
   */
  lease?: string;
  /**
   * Arbitrary key=value metadata to associate with the token
   * @format kvpairs
   */
  meta?: Record<string, never>;
  /**
   * Do not include default policy for this token
   */
  no_default_policy?: boolean;
  /**
   * Create the token with no parent
   */
  no_parent?: boolean;
  /**
   * Max number of uses for this token
   */
  num_uses?: number;
  /**
   * Renew period
   */
  period?: string;
  /**
   * List of policies for the token
   */
  policies?: string[];
  /**
   * Allow token to be renewed past its initial TTL up to system/mount maximum TTL
   */
  renewable?: boolean;
  /**
   * Time to live for this token
   */
  ttl?: string;
  /**
   * Token type
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-create.type.d.ts
interface TokenCreateResponseBodies {
  200: void;
}
interface TokenCreateRequestBodies {
  'application/json': TokenCreateRequest;
}
type TokenCreateRequestQuery = {};
type TokenCreateRouteParameters = {};
type TokenCreateRequestHeaders = {};
interface TokenCreateParameterBodies {
  'application/json': TokenCreateRequest & {
    [key: string]: any;
  };
}
type TokenCreateRequestParameters = TokenCreateRequestQuery & TokenCreateRouteParameters & TokenCreateRequestHeaders & TokenCreateRequestBodies['application/json'];
interface TokenCreateOperation<STATUS extends keyof TokenCreateResponseBodies, CONTENT_TYPE extends keyof TokenCreateParameterBodies> extends KeqOperation {
  requestParams: TokenCreateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenCreateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenCreateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenCreateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenCreateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-create-orphan-request.schema.d.ts
interface TokenCreateOrphanRequest {
  /**
   * Name to associate with this token
   */
  display_name?: string;
  /**
   * Name of the entity alias to associate with this token
   */
  entity_alias?: string;
  /**
   * Explicit Max TTL of this token
   */
  explicit_max_ttl?: string;
  /**
   * Value for the token
   */
  id?: string;
  /**
   * Use 'ttl' instead
   * @deprecated
   */
  lease?: string;
  /**
   * Arbitrary key=value metadata to associate with the token
   * @format kvpairs
   */
  meta?: Record<string, never>;
  /**
   * Do not include default policy for this token
   */
  no_default_policy?: boolean;
  /**
   * Create the token with no parent
   */
  no_parent?: boolean;
  /**
   * Max number of uses for this token
   */
  num_uses?: number;
  /**
   * Renew period
   */
  period?: string;
  /**
   * List of policies for the token
   */
  policies?: string[];
  /**
   * Allow token to be renewed past its initial TTL up to system/mount maximum TTL
   */
  renewable?: boolean;
  /**
   * Time to live for this token
   */
  ttl?: string;
  /**
   * Token type
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-create-orphan.type.d.ts
interface TokenCreateOrphanResponseBodies {
  200: void;
}
interface TokenCreateOrphanRequestBodies {
  'application/json': TokenCreateOrphanRequest;
}
type TokenCreateOrphanRequestQuery = {};
type TokenCreateOrphanRouteParameters = {};
type TokenCreateOrphanRequestHeaders = {};
interface TokenCreateOrphanParameterBodies {
  'application/json': TokenCreateOrphanRequest & {
    [key: string]: any;
  };
}
type TokenCreateOrphanRequestParameters = TokenCreateOrphanRequestQuery & TokenCreateOrphanRouteParameters & TokenCreateOrphanRequestHeaders & TokenCreateOrphanRequestBodies['application/json'];
interface TokenCreateOrphanOperation<STATUS extends keyof TokenCreateOrphanResponseBodies, CONTENT_TYPE extends keyof TokenCreateOrphanParameterBodies> extends KeqOperation {
  requestParams: TokenCreateOrphanRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenCreateOrphanRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenCreateOrphanRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenCreateOrphanParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenCreateOrphanResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-create-against-role-request.schema.d.ts
interface TokenCreateAgainstRoleRequest {
  /**
   * Name to associate with this token
   */
  display_name?: string;
  /**
   * Name of the entity alias to associate with this token
   */
  entity_alias?: string;
  /**
   * Explicit Max TTL of this token
   */
  explicit_max_ttl?: string;
  /**
   * Value for the token
   */
  id?: string;
  /**
   * Use 'ttl' instead
   * @deprecated
   */
  lease?: string;
  /**
   * Arbitrary key=value metadata to associate with the token
   * @format kvpairs
   */
  meta?: Record<string, never>;
  /**
   * Do not include default policy for this token
   */
  no_default_policy?: boolean;
  /**
   * Create the token with no parent
   */
  no_parent?: boolean;
  /**
   * Max number of uses for this token
   */
  num_uses?: number;
  /**
   * Renew period
   */
  period?: string;
  /**
   * List of policies for the token
   */
  policies?: string[];
  /**
   * Allow token to be renewed past its initial TTL up to system/mount maximum TTL
   */
  renewable?: boolean;
  /**
   * Time to live for this token
   */
  ttl?: string;
  /**
   * Token type
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-create-against-role.type.d.ts
interface TokenCreateAgainstRoleResponseBodies {
  200: void;
}
interface TokenCreateAgainstRoleRequestBodies {
  'application/json': TokenCreateAgainstRoleRequest;
}
type TokenCreateAgainstRoleRequestQuery = {};
type TokenCreateAgainstRoleRouteParameters = {};
type TokenCreateAgainstRoleRequestHeaders = {};
interface TokenCreateAgainstRoleParameterBodies {
  'application/json': TokenCreateAgainstRoleRequest & {
    [key: string]: any;
  };
}
type TokenCreateAgainstRoleRequestParameters = TokenCreateAgainstRoleRequestQuery & TokenCreateAgainstRoleRouteParameters & TokenCreateAgainstRoleRequestHeaders & TokenCreateAgainstRoleRequestBodies['application/json'];
interface TokenCreateAgainstRoleOperation<STATUS extends keyof TokenCreateAgainstRoleResponseBodies, CONTENT_TYPE extends keyof TokenCreateAgainstRoleParameterBodies> extends KeqOperation {
  requestParams: TokenCreateAgainstRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenCreateAgainstRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenCreateAgainstRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenCreateAgainstRoleParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenCreateAgainstRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-lookup-response.schema.d.ts
interface TokenLookupResponse {
  /**
   * Token accessor
   */
  accessor?: string;
  /**
   * List of CIDR blocks bound to the token
   */
  bound_cidrs?: string[];
  /**
   * Token creation time (Unix timestamp)
   * @format int64
   */
  creation_time?: number;
  /**
   * Token creation TTL in seconds
   * @format int64
   */
  creation_ttl?: number;
  /**
   * Display name of the token
   */
  display_name?: string;
  /**
   * Entity ID associated with the token
   */
  entity_id?: string;
  /**
   * Token expiration time
   * @format date-time
   */
  expire_time?: string;
  /**
   * Token explicit maximum TTL in seconds
   * @format int64
   */
  explicit_max_ttl?: number;
  /**
   * Derived identity policies for external namespaces (present only when applicable)
   * @format map
   */
  external_namespace_policies?: Record<string, never>;
  /**
   * Token ID (may be empty for self-lookup operations)
   */
  id?: string;
  /**
   * Identity policies associated with the token (present only when token has an entity and derived policies)
   */
  identity_policies?: string[];
  /**
   * Token issue time
   * @format date-time
   */
  issue_time?: string;
  /**
   * Last renewal time
   * @format date-time
   */
  last_renewal?: string;
  /**
   * Last renewal time (Unix timestamp)
   * @format int64
   */
  last_renewal_time?: number;
  /**
   * Token metadata
   * @format map
   */
  meta?: Record<string, never>;
  /**
   * Namespace path
   */
  namespace_path?: string;
  /**
   * Number of uses remaining
   */
  num_uses?: number;
  /**
   * Whether the token is an orphan
   */
  orphan?: boolean;
  /**
   * Path where the token was created
   */
  path?: string;
  /**
   * Token period in seconds
   * @format int64
   */
  period?: number;
  /**
   * List of policies associated with the token
   */
  policies?: string[];
  /**
   * Whether the token is renewable
   */
  renewable?: boolean;
  /**
   * Role name used to create the token
   */
  role?: string;
  /**
   * Token TTL in seconds
   * @format int64
   */
  ttl?: number;
  /**
   * Token type
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-look-up-get.type.d.ts
interface TokenLookUpGetResponseBodies {
  200: TokenLookupResponse;
}
type TokenLookUpGetRequestQuery = {};
type TokenLookUpGetRouteParameters = {};
type TokenLookUpGetRequestHeaders = {};
type TokenLookUpGetRequestParameters = TokenLookUpGetRequestQuery & TokenLookUpGetRouteParameters & TokenLookUpGetRequestHeaders;
interface TokenLookUpGetOperation<STATUS extends keyof TokenLookUpGetResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenLookUpGetRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenLookUpGetRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenLookUpGetRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenLookUpGetResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-look-up-update-request.schema.d.ts
interface TokenLookUpUpdateRequest {
  /**
   * Token to lookup (POST request body)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-look-up-update.type.d.ts
interface TokenLookUpUpdateResponseBodies {
  200: TokenLookupResponse;
}
interface TokenLookUpUpdateRequestBodies {
  'application/json': TokenLookUpUpdateRequest;
}
type TokenLookUpUpdateRequestQuery = {};
type TokenLookUpUpdateRouteParameters = {};
type TokenLookUpUpdateRequestHeaders = {};
interface TokenLookUpUpdateParameterBodies {
  'application/json': TokenLookUpUpdateRequest & {
    [key: string]: any;
  };
}
type TokenLookUpUpdateRequestParameters = TokenLookUpUpdateRequestQuery & TokenLookUpUpdateRouteParameters & TokenLookUpUpdateRequestHeaders & TokenLookUpUpdateRequestBodies['application/json'];
interface TokenLookUpUpdateOperation<STATUS extends keyof TokenLookUpUpdateResponseBodies, CONTENT_TYPE extends keyof TokenLookUpUpdateParameterBodies> extends KeqOperation {
  requestParams: TokenLookUpUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenLookUpUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenLookUpUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenLookUpUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenLookUpUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-look-up-by-accessor-request.schema.d.ts
interface TokenLookUpByAccessorRequest {
  /**
   * Accessor of the token to look up (request body)
   */
  accessor?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-look-up-by-accessor.type.d.ts
interface TokenLookUpByAccessorResponseBodies {
  200: TokenLookupResponse;
}
interface TokenLookUpByAccessorRequestBodies {
  'application/json': TokenLookUpByAccessorRequest;
}
type TokenLookUpByAccessorRequestQuery = {};
type TokenLookUpByAccessorRouteParameters = {};
type TokenLookUpByAccessorRequestHeaders = {};
interface TokenLookUpByAccessorParameterBodies {
  'application/json': TokenLookUpByAccessorRequest & {
    [key: string]: any;
  };
}
type TokenLookUpByAccessorRequestParameters = TokenLookUpByAccessorRequestQuery & TokenLookUpByAccessorRouteParameters & TokenLookUpByAccessorRequestHeaders & TokenLookUpByAccessorRequestBodies['application/json'];
interface TokenLookUpByAccessorOperation<STATUS extends keyof TokenLookUpByAccessorResponseBodies, CONTENT_TYPE extends keyof TokenLookUpByAccessorParameterBodies> extends KeqOperation {
  requestParams: TokenLookUpByAccessorRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenLookUpByAccessorRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenLookUpByAccessorRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenLookUpByAccessorParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenLookUpByAccessorResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-look-up-self-get.type.d.ts
interface TokenLookUpSelfGetResponseBodies {
  200: TokenLookupResponse;
}
type TokenLookUpSelfGetRequestQuery = {};
type TokenLookUpSelfGetRouteParameters = {};
type TokenLookUpSelfGetRequestHeaders = {};
type TokenLookUpSelfGetRequestParameters = TokenLookUpSelfGetRequestQuery & TokenLookUpSelfGetRouteParameters & TokenLookUpSelfGetRequestHeaders;
interface TokenLookUpSelfGetOperation<STATUS extends keyof TokenLookUpSelfGetResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenLookUpSelfGetRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenLookUpSelfGetRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenLookUpSelfGetRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenLookUpSelfGetResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-look-up-self-update-request.schema.d.ts
interface TokenLookUpSelfUpdateRequest {
  /**
   * Token to look up (unused, does not need to be set)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-look-up-self-update.type.d.ts
interface TokenLookUpSelfUpdateResponseBodies {
  200: TokenLookupResponse;
}
interface TokenLookUpSelfUpdateRequestBodies {
  'application/json': TokenLookUpSelfUpdateRequest;
}
type TokenLookUpSelfUpdateRequestQuery = {};
type TokenLookUpSelfUpdateRouteParameters = {};
type TokenLookUpSelfUpdateRequestHeaders = {};
interface TokenLookUpSelfUpdateParameterBodies {
  'application/json': TokenLookUpSelfUpdateRequest & {
    [key: string]: any;
  };
}
type TokenLookUpSelfUpdateRequestParameters = TokenLookUpSelfUpdateRequestQuery & TokenLookUpSelfUpdateRouteParameters & TokenLookUpSelfUpdateRequestHeaders & TokenLookUpSelfUpdateRequestBodies['application/json'];
interface TokenLookUpSelfUpdateOperation<STATUS extends keyof TokenLookUpSelfUpdateResponseBodies, CONTENT_TYPE extends keyof TokenLookUpSelfUpdateParameterBodies> extends KeqOperation {
  requestParams: TokenLookUpSelfUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenLookUpSelfUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenLookUpSelfUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenLookUpSelfUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenLookUpSelfUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-renew-request.schema.d.ts
interface TokenRenewRequest {
  /**
   * The desired increment in seconds to the token expiration
   * @format seconds
   */
  increment?: number;
  /**
   * Token to renew (request body)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-renew.type.d.ts
interface TokenRenewResponseBodies {
  200: void;
}
interface TokenRenewRequestBodies {
  'application/json': TokenRenewRequest;
}
type TokenRenewRequestQuery = {};
type TokenRenewRouteParameters = {};
type TokenRenewRequestHeaders = {};
interface TokenRenewParameterBodies {
  'application/json': TokenRenewRequest & {
    [key: string]: any;
  };
}
type TokenRenewRequestParameters = TokenRenewRequestQuery & TokenRenewRouteParameters & TokenRenewRequestHeaders & TokenRenewRequestBodies['application/json'];
interface TokenRenewOperation<STATUS extends keyof TokenRenewResponseBodies, CONTENT_TYPE extends keyof TokenRenewParameterBodies> extends KeqOperation {
  requestParams: TokenRenewRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRenewRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRenewRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRenewParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRenewResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-renew-accessor-request.schema.d.ts
interface TokenRenewAccessorRequest {
  /**
   * Accessor of the token to renew (request body)
   */
  accessor?: string;
  /**
   * The desired increment in seconds to the token expiration
   * @format seconds
   */
  increment?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-renew-accessor.type.d.ts
interface TokenRenewAccessorResponseBodies {
  200: void;
}
interface TokenRenewAccessorRequestBodies {
  'application/json': TokenRenewAccessorRequest;
}
type TokenRenewAccessorRequestQuery = {};
type TokenRenewAccessorRouteParameters = {};
type TokenRenewAccessorRequestHeaders = {};
interface TokenRenewAccessorParameterBodies {
  'application/json': TokenRenewAccessorRequest & {
    [key: string]: any;
  };
}
type TokenRenewAccessorRequestParameters = TokenRenewAccessorRequestQuery & TokenRenewAccessorRouteParameters & TokenRenewAccessorRequestHeaders & TokenRenewAccessorRequestBodies['application/json'];
interface TokenRenewAccessorOperation<STATUS extends keyof TokenRenewAccessorResponseBodies, CONTENT_TYPE extends keyof TokenRenewAccessorParameterBodies> extends KeqOperation {
  requestParams: TokenRenewAccessorRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRenewAccessorRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRenewAccessorRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRenewAccessorParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRenewAccessorResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-renew-self-request.schema.d.ts
interface TokenRenewSelfRequest {
  /**
   * The desired increment in seconds to the token expiration
   * @format seconds
   */
  increment?: number;
  /**
   * Token to renew (unused, does not need to be set)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-renew-self.type.d.ts
interface TokenRenewSelfResponseBodies {
  200: void;
}
interface TokenRenewSelfRequestBodies {
  'application/json': TokenRenewSelfRequest;
}
type TokenRenewSelfRequestQuery = {};
type TokenRenewSelfRouteParameters = {};
type TokenRenewSelfRequestHeaders = {};
interface TokenRenewSelfParameterBodies {
  'application/json': TokenRenewSelfRequest & {
    [key: string]: any;
  };
}
type TokenRenewSelfRequestParameters = TokenRenewSelfRequestQuery & TokenRenewSelfRouteParameters & TokenRenewSelfRequestHeaders & TokenRenewSelfRequestBodies['application/json'];
interface TokenRenewSelfOperation<STATUS extends keyof TokenRenewSelfResponseBodies, CONTENT_TYPE extends keyof TokenRenewSelfParameterBodies> extends KeqOperation {
  requestParams: TokenRenewSelfRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRenewSelfRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRenewSelfRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRenewSelfParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRenewSelfResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-revoke-request.schema.d.ts
interface TokenRevokeRequest {
  /**
   * Token to revoke (request body)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-revoke.type.d.ts
interface TokenRevokeResponseBodies {
  200: void;
}
interface TokenRevokeRequestBodies {
  'application/json': TokenRevokeRequest;
}
type TokenRevokeRequestQuery = {};
type TokenRevokeRouteParameters = {};
type TokenRevokeRequestHeaders = {};
interface TokenRevokeParameterBodies {
  'application/json': TokenRevokeRequest & {
    [key: string]: any;
  };
}
type TokenRevokeRequestParameters = TokenRevokeRequestQuery & TokenRevokeRouteParameters & TokenRevokeRequestHeaders & TokenRevokeRequestBodies['application/json'];
interface TokenRevokeOperation<STATUS extends keyof TokenRevokeResponseBodies, CONTENT_TYPE extends keyof TokenRevokeParameterBodies> extends KeqOperation {
  requestParams: TokenRevokeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRevokeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRevokeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRevokeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRevokeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-revoke-accessor-request.schema.d.ts
interface TokenRevokeAccessorRequest {
  /**
   * Accessor of the token (request body)
   */
  accessor?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-revoke-accessor.type.d.ts
interface TokenRevokeAccessorResponseBodies {
  200: void;
}
interface TokenRevokeAccessorRequestBodies {
  'application/json': TokenRevokeAccessorRequest;
}
type TokenRevokeAccessorRequestQuery = {};
type TokenRevokeAccessorRouteParameters = {};
type TokenRevokeAccessorRequestHeaders = {};
interface TokenRevokeAccessorParameterBodies {
  'application/json': TokenRevokeAccessorRequest & {
    [key: string]: any;
  };
}
type TokenRevokeAccessorRequestParameters = TokenRevokeAccessorRequestQuery & TokenRevokeAccessorRouteParameters & TokenRevokeAccessorRequestHeaders & TokenRevokeAccessorRequestBodies['application/json'];
interface TokenRevokeAccessorOperation<STATUS extends keyof TokenRevokeAccessorResponseBodies, CONTENT_TYPE extends keyof TokenRevokeAccessorParameterBodies> extends KeqOperation {
  requestParams: TokenRevokeAccessorRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRevokeAccessorRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRevokeAccessorRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRevokeAccessorParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRevokeAccessorResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-revoke-orphan-request.schema.d.ts
interface TokenRevokeOrphanRequest {
  /**
   * Token to revoke (request body)
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-revoke-orphan.type.d.ts
interface TokenRevokeOrphanResponseBodies {
  200: void;
}
interface TokenRevokeOrphanRequestBodies {
  'application/json': TokenRevokeOrphanRequest;
}
type TokenRevokeOrphanRequestQuery = {};
type TokenRevokeOrphanRouteParameters = {};
type TokenRevokeOrphanRequestHeaders = {};
interface TokenRevokeOrphanParameterBodies {
  'application/json': TokenRevokeOrphanRequest & {
    [key: string]: any;
  };
}
type TokenRevokeOrphanRequestParameters = TokenRevokeOrphanRequestQuery & TokenRevokeOrphanRouteParameters & TokenRevokeOrphanRequestHeaders & TokenRevokeOrphanRequestBodies['application/json'];
interface TokenRevokeOrphanOperation<STATUS extends keyof TokenRevokeOrphanResponseBodies, CONTENT_TYPE extends keyof TokenRevokeOrphanParameterBodies> extends KeqOperation {
  requestParams: TokenRevokeOrphanRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRevokeOrphanRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRevokeOrphanRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenRevokeOrphanParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenRevokeOrphanResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-revoke-self.type.d.ts
interface TokenRevokeSelfResponseBodies {
  200: void;
}
type TokenRevokeSelfRequestQuery = {};
type TokenRevokeSelfRouteParameters = {};
type TokenRevokeSelfRequestHeaders = {};
type TokenRevokeSelfRequestParameters = TokenRevokeSelfRequestQuery & TokenRevokeSelfRouteParameters & TokenRevokeSelfRequestHeaders;
interface TokenRevokeSelfOperation<STATUS extends keyof TokenRevokeSelfResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenRevokeSelfRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenRevokeSelfRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenRevokeSelfRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenRevokeSelfResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-list-roles.type.d.ts
interface TokenListRolesResponseBodies {
  200: void;
}
type TokenListRolesRequestQuery = {
  list: ('true');
};
type TokenListRolesRouteParameters = {};
type TokenListRolesRequestHeaders = {};
type TokenListRolesRequestParameters = TokenListRolesRequestQuery & TokenListRolesRouteParameters & TokenListRolesRequestHeaders;
interface TokenListRolesOperation<STATUS extends keyof TokenListRolesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenListRolesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenListRolesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenListRolesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenListRolesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-read-role.type.d.ts
interface TokenReadRoleResponseBodies {
  200: void;
}
type TokenReadRoleRequestQuery = {};
type TokenReadRoleRouteParameters = {};
type TokenReadRoleRequestHeaders = {};
type TokenReadRoleRequestParameters = TokenReadRoleRequestQuery & TokenReadRoleRouteParameters & TokenReadRoleRequestHeaders;
interface TokenReadRoleOperation<STATUS extends keyof TokenReadRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenReadRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenReadRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenReadRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenReadRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/token-write-role-request.schema.d.ts
interface TokenWriteRoleRequest {
  /**
   * String or JSON list of allowed entity aliases. If set, specifies the entity aliases which are allowed to be used during token generation. This field supports globbing.
   */
  allowed_entity_aliases?: string[];
  /**
   * If set, tokens can be created with any subset of the policies in this list, rather than the normal semantics of tokens being a subset of the calling token's policies. The parameter is a comma-delimited string of policy names.
   */
  allowed_policies?: string[];
  /**
   * If set, tokens can be created with any subset of glob matched policies in this list, rather than the normal semantics of tokens being a subset of the calling token's policies. The parameter is a comma-delimited string of policy name globs.
   */
  allowed_policies_glob?: string[];
  /**
   * Use 'token_bound_cidrs' instead.
   * @deprecated
   */
  bound_cidrs?: string[];
  /**
   * If set, successful token creation via this role will require that no policies in the given list are requested. The parameter is a comma-delimited string of policy names.
   */
  disallowed_policies?: string[];
  /**
   * If set, successful token creation via this role will require that no requested policies glob match any of policies in this list. The parameter is a comma-delimited string of policy name globs.
   */
  disallowed_policies_glob?: string[];
  /**
   * Use 'token_explicit_max_ttl' instead.
   * @deprecated
   * @format seconds
   */
  explicit_max_ttl?: number;
  /**
   * If true, tokens created via this role will be orphan tokens (have no parent)
   */
  orphan?: boolean;
  /**
   * If set, tokens created via this role will contain the given suffix as a part of their path. This can be used to assist use of the 'revoke-prefix' endpoint later on. The given suffix must match the regular expression.\w[\w-.]+\w
   */
  path_suffix?: string;
  /**
   * Use 'token_period' instead.
   * @deprecated
   * @format seconds
   */
  period?: number;
  /**
   * Tokens created via this role will be renewable or not according to this value. Defaults to "true".
   */
  renewable?: boolean;
  /**
   * Comma separated string or JSON list of CIDR blocks. If set, specifies the blocks of IP addresses which are allowed to use the generated token.
   */
  token_bound_cidrs?: string[];
  /**
   * If set, tokens created via this role carry an explicit maximum TTL. During renewal, the current maximum TTL values of the role and the mount are not checked for changes, and any updates to these values will have no effect on the token being renewed.
   * @format seconds
   */
  token_explicit_max_ttl?: number;
  /**
   * If true, the 'default' policy will not automatically be added to generated tokens
   */
  token_no_default_policy?: boolean;
  /**
   * The maximum number of times a token may be used, a value of zero means unlimited
   */
  token_num_uses?: number;
  /**
   * If set, tokens created via this role will have no max lifetime; instead, their renewal period will be fixed to this value. This takes an integer number of seconds, or a string duration (e.g. "24h").
   * @format seconds
   */
  token_period?: number;
  /**
   * The type of token to generate, service or batch
   */
  token_type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-write-role.type.d.ts
interface TokenWriteRoleResponseBodies {
  200: void;
}
interface TokenWriteRoleRequestBodies {
  'application/json': TokenWriteRoleRequest;
}
type TokenWriteRoleRequestQuery = {};
type TokenWriteRoleRouteParameters = {};
type TokenWriteRoleRequestHeaders = {};
interface TokenWriteRoleParameterBodies {
  'application/json': TokenWriteRoleRequest & {
    [key: string]: any;
  };
}
type TokenWriteRoleRequestParameters = TokenWriteRoleRequestQuery & TokenWriteRoleRouteParameters & TokenWriteRoleRequestHeaders & TokenWriteRoleRequestBodies['application/json'];
interface TokenWriteRoleOperation<STATUS extends keyof TokenWriteRoleResponseBodies, CONTENT_TYPE extends keyof TokenWriteRoleParameterBodies> extends KeqOperation {
  requestParams: TokenWriteRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenWriteRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenWriteRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TokenWriteRoleParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TokenWriteRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-delete-role.type.d.ts
interface TokenDeleteRoleResponseBodies {
  204: void;
}
type TokenDeleteRoleRequestQuery = {};
type TokenDeleteRoleRouteParameters = {};
type TokenDeleteRoleRequestHeaders = {};
type TokenDeleteRoleRequestParameters = TokenDeleteRoleRequestQuery & TokenDeleteRoleRouteParameters & TokenDeleteRoleRequestHeaders;
interface TokenDeleteRoleOperation<STATUS extends keyof TokenDeleteRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenDeleteRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenDeleteRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenDeleteRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenDeleteRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/token-tidy.type.d.ts
interface TokenTidyResponseBodies {
  200: void;
}
type TokenTidyRequestQuery = {};
type TokenTidyRouteParameters = {};
type TokenTidyRequestHeaders = {};
type TokenTidyRequestParameters = TokenTidyRequestQuery & TokenTidyRouteParameters & TokenTidyRequestHeaders;
interface TokenTidyOperation<STATUS extends keyof TokenTidyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TokenTidyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TokenTidyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TokenTidyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TokenTidyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/userpass-login-request.schema.d.ts
interface UserpassLoginRequest {
  /**
   * Password for this user.
   */
  password?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-login.type.d.ts
interface UserpassLoginResponseBodies {
  200: void;
}
interface UserpassLoginRequestBodies {
  'application/json': UserpassLoginRequest;
}
type UserpassLoginRequestQuery = {};
type UserpassLoginRouteParameters = {};
type UserpassLoginRequestHeaders = {};
interface UserpassLoginParameterBodies {
  'application/json': UserpassLoginRequest & {
    [key: string]: any;
  };
}
type UserpassLoginRequestParameters = UserpassLoginRequestQuery & UserpassLoginRouteParameters & UserpassLoginRequestHeaders & UserpassLoginRequestBodies['application/json'];
interface UserpassLoginOperation<STATUS extends keyof UserpassLoginResponseBodies, CONTENT_TYPE extends keyof UserpassLoginParameterBodies> extends KeqOperation {
  requestParams: UserpassLoginRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassLoginRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassLoginRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UserpassLoginParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UserpassLoginResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-list-users.type.d.ts
interface UserpassListUsersResponseBodies {
  200: void;
}
type UserpassListUsersRequestQuery = {
  list: ('true');
};
type UserpassListUsersRouteParameters = {};
type UserpassListUsersRequestHeaders = {};
type UserpassListUsersRequestParameters = UserpassListUsersRequestQuery & UserpassListUsersRouteParameters & UserpassListUsersRequestHeaders;
interface UserpassListUsersOperation<STATUS extends keyof UserpassListUsersResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UserpassListUsersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassListUsersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassListUsersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UserpassListUsersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-read-user.type.d.ts
interface UserpassReadUserResponseBodies {
  200: void;
}
type UserpassReadUserRequestQuery = {};
type UserpassReadUserRouteParameters = {};
type UserpassReadUserRequestHeaders = {};
type UserpassReadUserRequestParameters = UserpassReadUserRequestQuery & UserpassReadUserRouteParameters & UserpassReadUserRequestHeaders;
interface UserpassReadUserOperation<STATUS extends keyof UserpassReadUserResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UserpassReadUserRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassReadUserRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassReadUserRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UserpassReadUserResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/userpass-write-user-request.schema.d.ts
interface UserpassWriteUserRequest {
  /**
   * Use "token_bound_cidrs" instead. If this and "token_bound_cidrs" are both specified, only "token_bound_cidrs" will be used.
   * @deprecated
   */
  bound_cidrs?: string[];
  /**
   * Use "token_max_ttl" instead. If this and "token_max_ttl" are both specified, only "token_max_ttl" will be used.
   * @deprecated
   * @format seconds
   */
  max_ttl?: number;
  /**
   * Password for this user.
   */
  password?: string;
  /**
   * Use "token_policies" instead. If this and "token_policies" are both specified, only "token_policies" will be used.
   * @deprecated
   */
  policies?: string[];
  /**
   * Comma separated string or JSON list of CIDR blocks. If set, specifies the blocks of IP addresses which are allowed to use the generated token.
   */
  token_bound_cidrs?: string[];
  /**
   * If set, tokens created via this role carry an explicit maximum TTL. During renewal, the current maximum TTL values of the role and the mount are not checked for changes, and any updates to these values will have no effect on the token being renewed.
   * @format seconds
   */
  token_explicit_max_ttl?: number;
  /**
   * The maximum lifetime of the generated token
   * @format seconds
   */
  token_max_ttl?: number;
  /**
   * If true, the 'default' policy will not automatically be added to generated tokens
   */
  token_no_default_policy?: boolean;
  /**
   * The maximum number of times a token may be used, a value of zero means unlimited
   */
  token_num_uses?: number;
  /**
   * If set, tokens created via this role will have no max lifetime; instead, their renewal period will be fixed to this value. This takes an integer number of seconds, or a string duration (e.g. "24h").
   * @format seconds
   */
  token_period?: number;
  /**
   * Comma-separated list of policies
   */
  token_policies?: string[];
  /**
   * If true, CIDRs for the token will be strictly bound to the source IP address of the login request
   */
  token_strictly_bind_ip?: boolean;
  /**
   * The initial ttl of the token to generate
   * @format seconds
   */
  token_ttl?: number;
  /**
   * The type of token to generate, service or batch
   */
  token_type?: string;
  /**
   * Use "token_ttl" instead. If this and "token_ttl" are both specified, only "token_ttl" will be used.
   * @deprecated
   * @format seconds
   */
  ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-write-user.type.d.ts
interface UserpassWriteUserResponseBodies {
  200: void;
}
interface UserpassWriteUserRequestBodies {
  'application/json': UserpassWriteUserRequest;
}
type UserpassWriteUserRequestQuery = {};
type UserpassWriteUserRouteParameters = {};
type UserpassWriteUserRequestHeaders = {};
interface UserpassWriteUserParameterBodies {
  'application/json': UserpassWriteUserRequest & {
    [key: string]: any;
  };
}
type UserpassWriteUserRequestParameters = UserpassWriteUserRequestQuery & UserpassWriteUserRouteParameters & UserpassWriteUserRequestHeaders & UserpassWriteUserRequestBodies['application/json'];
interface UserpassWriteUserOperation<STATUS extends keyof UserpassWriteUserResponseBodies, CONTENT_TYPE extends keyof UserpassWriteUserParameterBodies> extends KeqOperation {
  requestParams: UserpassWriteUserRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassWriteUserRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassWriteUserRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UserpassWriteUserParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UserpassWriteUserResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-delete-user.type.d.ts
interface UserpassDeleteUserResponseBodies {
  204: void;
}
type UserpassDeleteUserRequestQuery = {};
type UserpassDeleteUserRouteParameters = {};
type UserpassDeleteUserRequestHeaders = {};
type UserpassDeleteUserRequestParameters = UserpassDeleteUserRequestQuery & UserpassDeleteUserRouteParameters & UserpassDeleteUserRequestHeaders;
interface UserpassDeleteUserOperation<STATUS extends keyof UserpassDeleteUserResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UserpassDeleteUserRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassDeleteUserRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassDeleteUserRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UserpassDeleteUserResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/userpass-reset-password-request.schema.d.ts
interface UserpassResetPasswordRequest {
  /**
   * Password for this user.
   */
  password?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-reset-password.type.d.ts
interface UserpassResetPasswordResponseBodies {
  200: void;
}
interface UserpassResetPasswordRequestBodies {
  'application/json': UserpassResetPasswordRequest;
}
type UserpassResetPasswordRequestQuery = {};
type UserpassResetPasswordRouteParameters = {};
type UserpassResetPasswordRequestHeaders = {};
interface UserpassResetPasswordParameterBodies {
  'application/json': UserpassResetPasswordRequest & {
    [key: string]: any;
  };
}
type UserpassResetPasswordRequestParameters = UserpassResetPasswordRequestQuery & UserpassResetPasswordRouteParameters & UserpassResetPasswordRequestHeaders & UserpassResetPasswordRequestBodies['application/json'];
interface UserpassResetPasswordOperation<STATUS extends keyof UserpassResetPasswordResponseBodies, CONTENT_TYPE extends keyof UserpassResetPasswordParameterBodies> extends KeqOperation {
  requestParams: UserpassResetPasswordRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassResetPasswordRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassResetPasswordRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UserpassResetPasswordParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UserpassResetPasswordResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/userpass-update-policies-request.schema.d.ts
interface UserpassUpdatePoliciesRequest {
  /**
   * Use "token_policies" instead. If this and "token_policies" are both specified, only "token_policies" will be used.
   * @deprecated
   */
  policies?: string[];
  /**
   * Comma-separated list of policies
   */
  token_policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/userpass-update-policies.type.d.ts
interface UserpassUpdatePoliciesResponseBodies {
  200: void;
}
interface UserpassUpdatePoliciesRequestBodies {
  'application/json': UserpassUpdatePoliciesRequest;
}
type UserpassUpdatePoliciesRequestQuery = {};
type UserpassUpdatePoliciesRouteParameters = {};
type UserpassUpdatePoliciesRequestHeaders = {};
interface UserpassUpdatePoliciesParameterBodies {
  'application/json': UserpassUpdatePoliciesRequest & {
    [key: string]: any;
  };
}
type UserpassUpdatePoliciesRequestParameters = UserpassUpdatePoliciesRequestQuery & UserpassUpdatePoliciesRouteParameters & UserpassUpdatePoliciesRequestHeaders & UserpassUpdatePoliciesRequestBodies['application/json'];
interface UserpassUpdatePoliciesOperation<STATUS extends keyof UserpassUpdatePoliciesResponseBodies, CONTENT_TYPE extends keyof UserpassUpdatePoliciesParameterBodies> extends KeqOperation {
  requestParams: UserpassUpdatePoliciesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UserpassUpdatePoliciesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UserpassUpdatePoliciesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UserpassUpdatePoliciesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UserpassUpdatePoliciesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cubbyhole-read.type.d.ts
interface CubbyholeReadResponseBodies {
  200: void;
}
type CubbyholeReadRequestQuery = {
  list?: string;
};
type CubbyholeReadRouteParameters = {};
type CubbyholeReadRequestHeaders = {};
type CubbyholeReadRequestParameters = CubbyholeReadRequestQuery & CubbyholeReadRouteParameters & CubbyholeReadRequestHeaders;
interface CubbyholeReadOperation<STATUS extends keyof CubbyholeReadResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CubbyholeReadRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CubbyholeReadRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CubbyholeReadRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CubbyholeReadResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cubbyhole-write.type.d.ts
interface CubbyholeWriteResponseBodies {
  200: void;
}
type CubbyholeWriteRequestQuery = {};
type CubbyholeWriteRouteParameters = {};
type CubbyholeWriteRequestHeaders = {};
type CubbyholeWriteRequestParameters = CubbyholeWriteRequestQuery & CubbyholeWriteRouteParameters & CubbyholeWriteRequestHeaders;
interface CubbyholeWriteOperation<STATUS extends keyof CubbyholeWriteResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CubbyholeWriteRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CubbyholeWriteRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CubbyholeWriteRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CubbyholeWriteResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cubbyhole-delete.type.d.ts
interface CubbyholeDeleteResponseBodies {
  204: void;
}
type CubbyholeDeleteRequestQuery = {};
type CubbyholeDeleteRouteParameters = {};
type CubbyholeDeleteRequestHeaders = {};
type CubbyholeDeleteRequestParameters = CubbyholeDeleteRequestQuery & CubbyholeDeleteRouteParameters & CubbyholeDeleteRequestHeaders;
interface CubbyholeDeleteOperation<STATUS extends keyof CubbyholeDeleteResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CubbyholeDeleteRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CubbyholeDeleteRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CubbyholeDeleteRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CubbyholeDeleteResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/alias-create-request.schema.d.ts
interface AliasCreateRequest {
  /**
   * Entity ID to which this alias belongs to
   */
  canonical_id?: string;
  /**
   * Entity ID to which this alias belongs to. This field is deprecated in favor of 'canonical_id'.
   */
  entity_id?: string;
  /**
   * ID of the alias
   */
  id?: string;
  /**
   * Mount accessor to which this alias belongs to
   */
  mount_accessor?: string;
  /**
   * Name of the alias
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/alias-create.type.d.ts
interface AliasCreateResponseBodies {
  200: void;
}
interface AliasCreateRequestBodies {
  'application/json': AliasCreateRequest;
}
type AliasCreateRequestQuery = {};
type AliasCreateRouteParameters = {};
type AliasCreateRequestHeaders = {};
interface AliasCreateParameterBodies {
  'application/json': AliasCreateRequest & {
    [key: string]: any;
  };
}
type AliasCreateRequestParameters = AliasCreateRequestQuery & AliasCreateRouteParameters & AliasCreateRequestHeaders & AliasCreateRequestBodies['application/json'];
interface AliasCreateOperation<STATUS extends keyof AliasCreateResponseBodies, CONTENT_TYPE extends keyof AliasCreateParameterBodies> extends KeqOperation {
  requestParams: AliasCreateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AliasCreateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AliasCreateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AliasCreateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AliasCreateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/alias-list-by-id.type.d.ts
interface AliasListByIdResponseBodies {
  200: void;
}
type AliasListByIdRequestQuery = {
  list: ('true');
};
type AliasListByIdRouteParameters = {};
type AliasListByIdRequestHeaders = {};
type AliasListByIdRequestParameters = AliasListByIdRequestQuery & AliasListByIdRouteParameters & AliasListByIdRequestHeaders;
interface AliasListByIdOperation<STATUS extends keyof AliasListByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AliasListByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AliasListByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AliasListByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AliasListByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/alias-read-by-id.type.d.ts
interface AliasReadByIdResponseBodies {
  200: void;
}
type AliasReadByIdRequestQuery = {};
type AliasReadByIdRouteParameters = {};
type AliasReadByIdRequestHeaders = {};
type AliasReadByIdRequestParameters = AliasReadByIdRequestQuery & AliasReadByIdRouteParameters & AliasReadByIdRequestHeaders;
interface AliasReadByIdOperation<STATUS extends keyof AliasReadByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AliasReadByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AliasReadByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AliasReadByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AliasReadByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/alias-update-by-id-request.schema.d.ts
interface AliasUpdateByIdRequest {
  /**
   * Entity ID to which this alias should be tied to
   */
  canonical_id?: string;
  /**
   * Entity ID to which this alias should be tied to. This field is deprecated in favor of 'canonical_id'.
   */
  entity_id?: string;
  /**
   * Mount accessor to which this alias belongs to
   */
  mount_accessor?: string;
  /**
   * Name of the alias
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/alias-update-by-id.type.d.ts
interface AliasUpdateByIdResponseBodies {
  200: void;
}
interface AliasUpdateByIdRequestBodies {
  'application/json': AliasUpdateByIdRequest;
}
type AliasUpdateByIdRequestQuery = {};
type AliasUpdateByIdRouteParameters = {};
type AliasUpdateByIdRequestHeaders = {};
interface AliasUpdateByIdParameterBodies {
  'application/json': AliasUpdateByIdRequest & {
    [key: string]: any;
  };
}
type AliasUpdateByIdRequestParameters = AliasUpdateByIdRequestQuery & AliasUpdateByIdRouteParameters & AliasUpdateByIdRequestHeaders & AliasUpdateByIdRequestBodies['application/json'];
interface AliasUpdateByIdOperation<STATUS extends keyof AliasUpdateByIdResponseBodies, CONTENT_TYPE extends keyof AliasUpdateByIdParameterBodies> extends KeqOperation {
  requestParams: AliasUpdateByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AliasUpdateByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AliasUpdateByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AliasUpdateByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AliasUpdateByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/alias-delete-by-id.type.d.ts
interface AliasDeleteByIdResponseBodies {
  204: void;
}
type AliasDeleteByIdRequestQuery = {};
type AliasDeleteByIdRouteParameters = {};
type AliasDeleteByIdRequestHeaders = {};
type AliasDeleteByIdRequestParameters = AliasDeleteByIdRequestQuery & AliasDeleteByIdRouteParameters & AliasDeleteByIdRequestHeaders;
interface AliasDeleteByIdOperation<STATUS extends keyof AliasDeleteByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AliasDeleteByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AliasDeleteByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AliasDeleteByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AliasDeleteByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-create-request.schema.d.ts
interface EntityCreateRequest {
  /**
   * If set true, tokens tied to this identity will not be able to be used (but will not be revoked).
   */
  disabled?: boolean;
  /**
   * ID of the entity. If set, updates the corresponding existing entity.
   */
  id?: string;
  /**
   * Metadata to be associated with the entity. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Name of the entity
   */
  name?: string;
  /**
   * Policies to be tied to the entity.
   */
  policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-create.type.d.ts
interface EntityCreateResponseBodies {
  200: void;
}
interface EntityCreateRequestBodies {
  'application/json': EntityCreateRequest;
}
type EntityCreateRequestQuery = {};
type EntityCreateRouteParameters = {};
type EntityCreateRequestHeaders = {};
interface EntityCreateParameterBodies {
  'application/json': EntityCreateRequest & {
    [key: string]: any;
  };
}
type EntityCreateRequestParameters = EntityCreateRequestQuery & EntityCreateRouteParameters & EntityCreateRequestHeaders & EntityCreateRequestBodies['application/json'];
interface EntityCreateOperation<STATUS extends keyof EntityCreateResponseBodies, CONTENT_TYPE extends keyof EntityCreateParameterBodies> extends KeqOperation {
  requestParams: EntityCreateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityCreateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityCreateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityCreateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityCreateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-create-alias-request.schema.d.ts
interface EntityCreateAliasRequest {
  /**
   * Entity ID to which this alias belongs
   */
  canonical_id?: string;
  /**
   * User provided key-value pairs
   * @format kvpairs
   */
  custom_metadata?: Record<string, never>;
  /**
   * Entity ID to which this alias belongs. This field is deprecated, use canonical_id.
   */
  entity_id?: string;
  /**
   * ID of the entity alias. If set, updates the corresponding entity alias.
   */
  id?: string;
  /**
   * Mount accessor to which this alias belongs to; unused for a modify
   */
  mount_accessor?: string;
  /**
   * Name of the alias; unused for a modify
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-create-alias.type.d.ts
interface EntityCreateAliasResponseBodies {
  200: void;
}
interface EntityCreateAliasRequestBodies {
  'application/json': EntityCreateAliasRequest;
}
type EntityCreateAliasRequestQuery = {};
type EntityCreateAliasRouteParameters = {};
type EntityCreateAliasRequestHeaders = {};
interface EntityCreateAliasParameterBodies {
  'application/json': EntityCreateAliasRequest & {
    [key: string]: any;
  };
}
type EntityCreateAliasRequestParameters = EntityCreateAliasRequestQuery & EntityCreateAliasRouteParameters & EntityCreateAliasRequestHeaders & EntityCreateAliasRequestBodies['application/json'];
interface EntityCreateAliasOperation<STATUS extends keyof EntityCreateAliasResponseBodies, CONTENT_TYPE extends keyof EntityCreateAliasParameterBodies> extends KeqOperation {
  requestParams: EntityCreateAliasRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityCreateAliasRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityCreateAliasRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityCreateAliasParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityCreateAliasResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-list-aliases-by-id.type.d.ts
interface EntityListAliasesByIdResponseBodies {
  200: void;
}
type EntityListAliasesByIdRequestQuery = {
  list: ('true');
};
type EntityListAliasesByIdRouteParameters = {};
type EntityListAliasesByIdRequestHeaders = {};
type EntityListAliasesByIdRequestParameters = EntityListAliasesByIdRequestQuery & EntityListAliasesByIdRouteParameters & EntityListAliasesByIdRequestHeaders;
interface EntityListAliasesByIdOperation<STATUS extends keyof EntityListAliasesByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityListAliasesByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityListAliasesByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityListAliasesByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityListAliasesByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-read-alias-by-id.type.d.ts
interface EntityReadAliasByIdResponseBodies {
  200: void;
}
type EntityReadAliasByIdRequestQuery = {};
type EntityReadAliasByIdRouteParameters = {};
type EntityReadAliasByIdRequestHeaders = {};
type EntityReadAliasByIdRequestParameters = EntityReadAliasByIdRequestQuery & EntityReadAliasByIdRouteParameters & EntityReadAliasByIdRequestHeaders;
interface EntityReadAliasByIdOperation<STATUS extends keyof EntityReadAliasByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityReadAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityReadAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityReadAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityReadAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-update-alias-by-id-request.schema.d.ts
interface EntityUpdateAliasByIdRequest {
  /**
   * Entity ID to which this alias should be tied to
   */
  canonical_id?: string;
  /**
   * User provided key-value pairs
   * @format kvpairs
   */
  custom_metadata?: Record<string, never>;
  /**
   * Entity ID to which this alias belongs to. This field is deprecated, use canonical_id.
   */
  entity_id?: string;
  /**
   * (Unused)
   */
  mount_accessor?: string;
  /**
   * (Unused)
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-update-alias-by-id.type.d.ts
interface EntityUpdateAliasByIdResponseBodies {
  200: void;
}
interface EntityUpdateAliasByIdRequestBodies {
  'application/json': EntityUpdateAliasByIdRequest;
}
type EntityUpdateAliasByIdRequestQuery = {};
type EntityUpdateAliasByIdRouteParameters = {};
type EntityUpdateAliasByIdRequestHeaders = {};
interface EntityUpdateAliasByIdParameterBodies {
  'application/json': EntityUpdateAliasByIdRequest & {
    [key: string]: any;
  };
}
type EntityUpdateAliasByIdRequestParameters = EntityUpdateAliasByIdRequestQuery & EntityUpdateAliasByIdRouteParameters & EntityUpdateAliasByIdRequestHeaders & EntityUpdateAliasByIdRequestBodies['application/json'];
interface EntityUpdateAliasByIdOperation<STATUS extends keyof EntityUpdateAliasByIdResponseBodies, CONTENT_TYPE extends keyof EntityUpdateAliasByIdParameterBodies> extends KeqOperation {
  requestParams: EntityUpdateAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityUpdateAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityUpdateAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityUpdateAliasByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityUpdateAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-delete-alias-by-id.type.d.ts
interface EntityDeleteAliasByIdResponseBodies {
  204: void;
}
type EntityDeleteAliasByIdRequestQuery = {};
type EntityDeleteAliasByIdRouteParameters = {};
type EntityDeleteAliasByIdRequestHeaders = {};
type EntityDeleteAliasByIdRequestParameters = EntityDeleteAliasByIdRequestQuery & EntityDeleteAliasByIdRouteParameters & EntityDeleteAliasByIdRequestHeaders;
interface EntityDeleteAliasByIdOperation<STATUS extends keyof EntityDeleteAliasByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityDeleteAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityDeleteAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityDeleteAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityDeleteAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-batch-delete-request.schema.d.ts
interface EntityBatchDeleteRequest {
  /**
   * Entity IDs to delete
   */
  entity_ids?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-batch-delete.type.d.ts
interface EntityBatchDeleteResponseBodies {
  200: void;
}
interface EntityBatchDeleteRequestBodies {
  'application/json': EntityBatchDeleteRequest;
}
type EntityBatchDeleteRequestQuery = {};
type EntityBatchDeleteRouteParameters = {};
type EntityBatchDeleteRequestHeaders = {};
interface EntityBatchDeleteParameterBodies {
  'application/json': EntityBatchDeleteRequest & {
    [key: string]: any;
  };
}
type EntityBatchDeleteRequestParameters = EntityBatchDeleteRequestQuery & EntityBatchDeleteRouteParameters & EntityBatchDeleteRequestHeaders & EntityBatchDeleteRequestBodies['application/json'];
interface EntityBatchDeleteOperation<STATUS extends keyof EntityBatchDeleteResponseBodies, CONTENT_TYPE extends keyof EntityBatchDeleteParameterBodies> extends KeqOperation {
  requestParams: EntityBatchDeleteRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityBatchDeleteRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityBatchDeleteRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityBatchDeleteParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityBatchDeleteResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-list-by-id.type.d.ts
interface EntityListByIdResponseBodies {
  200: void;
}
type EntityListByIdRequestQuery = {
  list: ('true');
};
type EntityListByIdRouteParameters = {};
type EntityListByIdRequestHeaders = {};
type EntityListByIdRequestParameters = EntityListByIdRequestQuery & EntityListByIdRouteParameters & EntityListByIdRequestHeaders;
interface EntityListByIdOperation<STATUS extends keyof EntityListByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityListByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityListByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityListByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityListByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-read-by-id.type.d.ts
interface EntityReadByIdResponseBodies {
  200: void;
}
type EntityReadByIdRequestQuery = {};
type EntityReadByIdRouteParameters = {};
type EntityReadByIdRequestHeaders = {};
type EntityReadByIdRequestParameters = EntityReadByIdRequestQuery & EntityReadByIdRouteParameters & EntityReadByIdRequestHeaders;
interface EntityReadByIdOperation<STATUS extends keyof EntityReadByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityReadByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityReadByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityReadByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityReadByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-update-by-id-request.schema.d.ts
interface EntityUpdateByIdRequest {
  /**
   * If set true, tokens tied to this identity will not be able to be used (but will not be revoked).
   */
  disabled?: boolean;
  /**
   * Metadata to be associated with the entity. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Name of the entity
   */
  name?: string;
  /**
   * Policies to be tied to the entity.
   */
  policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-update-by-id.type.d.ts
interface EntityUpdateByIdResponseBodies {
  200: void;
}
interface EntityUpdateByIdRequestBodies {
  'application/json': EntityUpdateByIdRequest;
}
type EntityUpdateByIdRequestQuery = {};
type EntityUpdateByIdRouteParameters = {};
type EntityUpdateByIdRequestHeaders = {};
interface EntityUpdateByIdParameterBodies {
  'application/json': EntityUpdateByIdRequest & {
    [key: string]: any;
  };
}
type EntityUpdateByIdRequestParameters = EntityUpdateByIdRequestQuery & EntityUpdateByIdRouteParameters & EntityUpdateByIdRequestHeaders & EntityUpdateByIdRequestBodies['application/json'];
interface EntityUpdateByIdOperation<STATUS extends keyof EntityUpdateByIdResponseBodies, CONTENT_TYPE extends keyof EntityUpdateByIdParameterBodies> extends KeqOperation {
  requestParams: EntityUpdateByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityUpdateByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityUpdateByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityUpdateByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityUpdateByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-delete-by-id.type.d.ts
interface EntityDeleteByIdResponseBodies {
  204: void;
}
type EntityDeleteByIdRequestQuery = {};
type EntityDeleteByIdRouteParameters = {};
type EntityDeleteByIdRequestHeaders = {};
type EntityDeleteByIdRequestParameters = EntityDeleteByIdRequestQuery & EntityDeleteByIdRouteParameters & EntityDeleteByIdRequestHeaders;
interface EntityDeleteByIdOperation<STATUS extends keyof EntityDeleteByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityDeleteByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityDeleteByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityDeleteByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityDeleteByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-merge-request.schema.d.ts
interface EntityMergeRequest {
  /**
   * Alias IDs to keep in case of conflicting aliases. Ignored if no conflicting aliases found
   */
  conflicting_alias_ids_to_keep?: string[];
  /**
   * Setting this will follow the 'mine' strategy for merging MFA secrets. If there are secrets of the same type both in entities that are merged from and in entity into which all others are getting merged, secrets in the destination will be unaltered. If not set, this API will throw an error containing all the conflicts.
   */
  force?: boolean;
  /**
   * Entity IDs which need to get merged
   */
  from_entity_ids?: string[];
  /**
   * Entity ID into which all the other entities need to get merged
   */
  to_entity_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-merge.type.d.ts
interface EntityMergeResponseBodies {
  200: void;
}
interface EntityMergeRequestBodies {
  'application/json': EntityMergeRequest;
}
type EntityMergeRequestQuery = {};
type EntityMergeRouteParameters = {};
type EntityMergeRequestHeaders = {};
interface EntityMergeParameterBodies {
  'application/json': EntityMergeRequest & {
    [key: string]: any;
  };
}
type EntityMergeRequestParameters = EntityMergeRequestQuery & EntityMergeRouteParameters & EntityMergeRequestHeaders & EntityMergeRequestBodies['application/json'];
interface EntityMergeOperation<STATUS extends keyof EntityMergeResponseBodies, CONTENT_TYPE extends keyof EntityMergeParameterBodies> extends KeqOperation {
  requestParams: EntityMergeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityMergeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityMergeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityMergeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityMergeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-list-by-name.type.d.ts
interface EntityListByNameResponseBodies {
  200: void;
}
type EntityListByNameRequestQuery = {
  list: ('true');
};
type EntityListByNameRouteParameters = {};
type EntityListByNameRequestHeaders = {};
type EntityListByNameRequestParameters = EntityListByNameRequestQuery & EntityListByNameRouteParameters & EntityListByNameRequestHeaders;
interface EntityListByNameOperation<STATUS extends keyof EntityListByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityListByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityListByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityListByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityListByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-read-by-name.type.d.ts
interface EntityReadByNameResponseBodies {
  200: void;
}
type EntityReadByNameRequestQuery = {};
type EntityReadByNameRouteParameters = {};
type EntityReadByNameRequestHeaders = {};
type EntityReadByNameRequestParameters = EntityReadByNameRequestQuery & EntityReadByNameRouteParameters & EntityReadByNameRequestHeaders;
interface EntityReadByNameOperation<STATUS extends keyof EntityReadByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityReadByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityReadByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityReadByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityReadByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-update-by-name-request.schema.d.ts
interface EntityUpdateByNameRequest {
  /**
   * If set true, tokens tied to this identity will not be able to be used (but will not be revoked).
   */
  disabled?: boolean;
  /**
   * ID of the entity. If set, updates the corresponding existing entity.
   */
  id?: string;
  /**
   * Metadata to be associated with the entity. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Policies to be tied to the entity.
   */
  policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-update-by-name.type.d.ts
interface EntityUpdateByNameResponseBodies {
  200: void;
}
interface EntityUpdateByNameRequestBodies {
  'application/json': EntityUpdateByNameRequest;
}
type EntityUpdateByNameRequestQuery = {};
type EntityUpdateByNameRouteParameters = {};
type EntityUpdateByNameRequestHeaders = {};
interface EntityUpdateByNameParameterBodies {
  'application/json': EntityUpdateByNameRequest & {
    [key: string]: any;
  };
}
type EntityUpdateByNameRequestParameters = EntityUpdateByNameRequestQuery & EntityUpdateByNameRouteParameters & EntityUpdateByNameRequestHeaders & EntityUpdateByNameRequestBodies['application/json'];
interface EntityUpdateByNameOperation<STATUS extends keyof EntityUpdateByNameResponseBodies, CONTENT_TYPE extends keyof EntityUpdateByNameParameterBodies> extends KeqOperation {
  requestParams: EntityUpdateByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityUpdateByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityUpdateByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityUpdateByNameParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityUpdateByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-delete-by-name.type.d.ts
interface EntityDeleteByNameResponseBodies {
  204: void;
}
type EntityDeleteByNameRequestQuery = {};
type EntityDeleteByNameRouteParameters = {};
type EntityDeleteByNameRequestHeaders = {};
type EntityDeleteByNameRequestParameters = EntityDeleteByNameRequestQuery & EntityDeleteByNameRouteParameters & EntityDeleteByNameRequestHeaders;
interface EntityDeleteByNameOperation<STATUS extends keyof EntityDeleteByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EntityDeleteByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityDeleteByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityDeleteByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EntityDeleteByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-create-request.schema.d.ts
interface GroupCreateRequest {
  /**
   * ID of the group. If set, updates the corresponding existing group.
   */
  id?: string;
  /**
   * Entity IDs to be assigned as group members.
   */
  member_entity_ids?: string[];
  /**
   * Group IDs to be assigned as group members.
   */
  member_group_ids?: string[];
  /**
   * Metadata to be associated with the group. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Name of the group.
   */
  name?: string;
  /**
   * Policies to be tied to the group.
   */
  policies?: string[];
  /**
   * Type of the group, 'internal' or 'external'. Defaults to 'internal'
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-create.type.d.ts
interface GroupCreateResponseBodies {
  200: void;
}
interface GroupCreateRequestBodies {
  'application/json': GroupCreateRequest;
}
type GroupCreateRequestQuery = {};
type GroupCreateRouteParameters = {};
type GroupCreateRequestHeaders = {};
interface GroupCreateParameterBodies {
  'application/json': GroupCreateRequest & {
    [key: string]: any;
  };
}
type GroupCreateRequestParameters = GroupCreateRequestQuery & GroupCreateRouteParameters & GroupCreateRequestHeaders & GroupCreateRequestBodies['application/json'];
interface GroupCreateOperation<STATUS extends keyof GroupCreateResponseBodies, CONTENT_TYPE extends keyof GroupCreateParameterBodies> extends KeqOperation {
  requestParams: GroupCreateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupCreateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupCreateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupCreateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupCreateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-create-alias-request.schema.d.ts
interface GroupCreateAliasRequest {
  /**
   * ID of the group to which this is an alias.
   */
  canonical_id?: string;
  /**
   * ID of the group alias.
   */
  id?: string;
  /**
   * Mount accessor to which this alias belongs to.
   */
  mount_accessor?: string;
  /**
   * Alias of the group.
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-create-alias.type.d.ts
interface GroupCreateAliasResponseBodies {
  200: void;
}
interface GroupCreateAliasRequestBodies {
  'application/json': GroupCreateAliasRequest;
}
type GroupCreateAliasRequestQuery = {};
type GroupCreateAliasRouteParameters = {};
type GroupCreateAliasRequestHeaders = {};
interface GroupCreateAliasParameterBodies {
  'application/json': GroupCreateAliasRequest & {
    [key: string]: any;
  };
}
type GroupCreateAliasRequestParameters = GroupCreateAliasRequestQuery & GroupCreateAliasRouteParameters & GroupCreateAliasRequestHeaders & GroupCreateAliasRequestBodies['application/json'];
interface GroupCreateAliasOperation<STATUS extends keyof GroupCreateAliasResponseBodies, CONTENT_TYPE extends keyof GroupCreateAliasParameterBodies> extends KeqOperation {
  requestParams: GroupCreateAliasRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupCreateAliasRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupCreateAliasRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupCreateAliasParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupCreateAliasResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-list-aliases-by-id.type.d.ts
interface GroupListAliasesByIdResponseBodies {
  200: void;
}
type GroupListAliasesByIdRequestQuery = {
  list: ('true');
};
type GroupListAliasesByIdRouteParameters = {};
type GroupListAliasesByIdRequestHeaders = {};
type GroupListAliasesByIdRequestParameters = GroupListAliasesByIdRequestQuery & GroupListAliasesByIdRouteParameters & GroupListAliasesByIdRequestHeaders;
interface GroupListAliasesByIdOperation<STATUS extends keyof GroupListAliasesByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupListAliasesByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupListAliasesByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupListAliasesByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupListAliasesByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-read-alias-by-id.type.d.ts
interface GroupReadAliasByIdResponseBodies {
  200: void;
}
type GroupReadAliasByIdRequestQuery = {};
type GroupReadAliasByIdRouteParameters = {};
type GroupReadAliasByIdRequestHeaders = {};
type GroupReadAliasByIdRequestParameters = GroupReadAliasByIdRequestQuery & GroupReadAliasByIdRouteParameters & GroupReadAliasByIdRequestHeaders;
interface GroupReadAliasByIdOperation<STATUS extends keyof GroupReadAliasByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupReadAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupReadAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupReadAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupReadAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-update-alias-by-id-request.schema.d.ts
interface GroupUpdateAliasByIdRequest {
  /**
   * ID of the group to which this is an alias.
   */
  canonical_id?: string;
  /**
   * Mount accessor to which this alias belongs to.
   */
  mount_accessor?: string;
  /**
   * Alias of the group.
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-update-alias-by-id.type.d.ts
interface GroupUpdateAliasByIdResponseBodies {
  200: void;
}
interface GroupUpdateAliasByIdRequestBodies {
  'application/json': GroupUpdateAliasByIdRequest;
}
type GroupUpdateAliasByIdRequestQuery = {};
type GroupUpdateAliasByIdRouteParameters = {};
type GroupUpdateAliasByIdRequestHeaders = {};
interface GroupUpdateAliasByIdParameterBodies {
  'application/json': GroupUpdateAliasByIdRequest & {
    [key: string]: any;
  };
}
type GroupUpdateAliasByIdRequestParameters = GroupUpdateAliasByIdRequestQuery & GroupUpdateAliasByIdRouteParameters & GroupUpdateAliasByIdRequestHeaders & GroupUpdateAliasByIdRequestBodies['application/json'];
interface GroupUpdateAliasByIdOperation<STATUS extends keyof GroupUpdateAliasByIdResponseBodies, CONTENT_TYPE extends keyof GroupUpdateAliasByIdParameterBodies> extends KeqOperation {
  requestParams: GroupUpdateAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupUpdateAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupUpdateAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupUpdateAliasByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupUpdateAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-delete-alias-by-id.type.d.ts
interface GroupDeleteAliasByIdResponseBodies {
  204: void;
}
type GroupDeleteAliasByIdRequestQuery = {};
type GroupDeleteAliasByIdRouteParameters = {};
type GroupDeleteAliasByIdRequestHeaders = {};
type GroupDeleteAliasByIdRequestParameters = GroupDeleteAliasByIdRequestQuery & GroupDeleteAliasByIdRouteParameters & GroupDeleteAliasByIdRequestHeaders;
interface GroupDeleteAliasByIdOperation<STATUS extends keyof GroupDeleteAliasByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupDeleteAliasByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupDeleteAliasByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupDeleteAliasByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupDeleteAliasByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-list-by-id.type.d.ts
interface GroupListByIdResponseBodies {
  200: void;
}
type GroupListByIdRequestQuery = {
  list: ('true');
};
type GroupListByIdRouteParameters = {};
type GroupListByIdRequestHeaders = {};
type GroupListByIdRequestParameters = GroupListByIdRequestQuery & GroupListByIdRouteParameters & GroupListByIdRequestHeaders;
interface GroupListByIdOperation<STATUS extends keyof GroupListByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupListByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupListByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupListByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupListByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-read-by-id.type.d.ts
interface GroupReadByIdResponseBodies {
  200: void;
}
type GroupReadByIdRequestQuery = {};
type GroupReadByIdRouteParameters = {};
type GroupReadByIdRequestHeaders = {};
type GroupReadByIdRequestParameters = GroupReadByIdRequestQuery & GroupReadByIdRouteParameters & GroupReadByIdRequestHeaders;
interface GroupReadByIdOperation<STATUS extends keyof GroupReadByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupReadByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupReadByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupReadByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupReadByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-update-by-id-request.schema.d.ts
interface GroupUpdateByIdRequest {
  /**
   * Entity IDs to be assigned as group members.
   */
  member_entity_ids?: string[];
  /**
   * Group IDs to be assigned as group members.
   */
  member_group_ids?: string[];
  /**
   * Metadata to be associated with the group. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Name of the group.
   */
  name?: string;
  /**
   * Policies to be tied to the group.
   */
  policies?: string[];
  /**
   * Type of the group, 'internal' or 'external'. Defaults to 'internal'
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-update-by-id.type.d.ts
interface GroupUpdateByIdResponseBodies {
  200: void;
}
interface GroupUpdateByIdRequestBodies {
  'application/json': GroupUpdateByIdRequest;
}
type GroupUpdateByIdRequestQuery = {};
type GroupUpdateByIdRouteParameters = {};
type GroupUpdateByIdRequestHeaders = {};
interface GroupUpdateByIdParameterBodies {
  'application/json': GroupUpdateByIdRequest & {
    [key: string]: any;
  };
}
type GroupUpdateByIdRequestParameters = GroupUpdateByIdRequestQuery & GroupUpdateByIdRouteParameters & GroupUpdateByIdRequestHeaders & GroupUpdateByIdRequestBodies['application/json'];
interface GroupUpdateByIdOperation<STATUS extends keyof GroupUpdateByIdResponseBodies, CONTENT_TYPE extends keyof GroupUpdateByIdParameterBodies> extends KeqOperation {
  requestParams: GroupUpdateByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupUpdateByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupUpdateByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupUpdateByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupUpdateByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-delete-by-id.type.d.ts
interface GroupDeleteByIdResponseBodies {
  204: void;
}
type GroupDeleteByIdRequestQuery = {};
type GroupDeleteByIdRouteParameters = {};
type GroupDeleteByIdRequestHeaders = {};
type GroupDeleteByIdRequestParameters = GroupDeleteByIdRequestQuery & GroupDeleteByIdRouteParameters & GroupDeleteByIdRequestHeaders;
interface GroupDeleteByIdOperation<STATUS extends keyof GroupDeleteByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupDeleteByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupDeleteByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupDeleteByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupDeleteByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-list-by-name.type.d.ts
interface GroupListByNameResponseBodies {
  200: void;
}
type GroupListByNameRequestQuery = {
  list: ('true');
};
type GroupListByNameRouteParameters = {};
type GroupListByNameRequestHeaders = {};
type GroupListByNameRequestParameters = GroupListByNameRequestQuery & GroupListByNameRouteParameters & GroupListByNameRequestHeaders;
interface GroupListByNameOperation<STATUS extends keyof GroupListByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupListByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupListByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupListByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupListByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-read-by-name.type.d.ts
interface GroupReadByNameResponseBodies {
  200: void;
}
type GroupReadByNameRequestQuery = {};
type GroupReadByNameRouteParameters = {};
type GroupReadByNameRequestHeaders = {};
type GroupReadByNameRequestParameters = GroupReadByNameRequestQuery & GroupReadByNameRouteParameters & GroupReadByNameRequestHeaders;
interface GroupReadByNameOperation<STATUS extends keyof GroupReadByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupReadByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupReadByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupReadByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupReadByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-update-by-name-request.schema.d.ts
interface GroupUpdateByNameRequest {
  /**
   * ID of the group. If set, updates the corresponding existing group.
   */
  id?: string;
  /**
   * Entity IDs to be assigned as group members.
   */
  member_entity_ids?: string[];
  /**
   * Group IDs to be assigned as group members.
   */
  member_group_ids?: string[];
  /**
   * Metadata to be associated with the group. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Policies to be tied to the group.
   */
  policies?: string[];
  /**
   * Type of the group, 'internal' or 'external'. Defaults to 'internal'
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-update-by-name.type.d.ts
interface GroupUpdateByNameResponseBodies {
  200: void;
}
interface GroupUpdateByNameRequestBodies {
  'application/json': GroupUpdateByNameRequest;
}
type GroupUpdateByNameRequestQuery = {};
type GroupUpdateByNameRouteParameters = {};
type GroupUpdateByNameRequestHeaders = {};
interface GroupUpdateByNameParameterBodies {
  'application/json': GroupUpdateByNameRequest & {
    [key: string]: any;
  };
}
type GroupUpdateByNameRequestParameters = GroupUpdateByNameRequestQuery & GroupUpdateByNameRouteParameters & GroupUpdateByNameRequestHeaders & GroupUpdateByNameRequestBodies['application/json'];
interface GroupUpdateByNameOperation<STATUS extends keyof GroupUpdateByNameResponseBodies, CONTENT_TYPE extends keyof GroupUpdateByNameParameterBodies> extends KeqOperation {
  requestParams: GroupUpdateByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupUpdateByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupUpdateByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupUpdateByNameParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupUpdateByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-delete-by-name.type.d.ts
interface GroupDeleteByNameResponseBodies {
  204: void;
}
type GroupDeleteByNameRequestQuery = {};
type GroupDeleteByNameRouteParameters = {};
type GroupDeleteByNameRequestHeaders = {};
type GroupDeleteByNameRequestParameters = GroupDeleteByNameRequestQuery & GroupDeleteByNameRouteParameters & GroupDeleteByNameRequestHeaders;
interface GroupDeleteByNameOperation<STATUS extends keyof GroupDeleteByNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: GroupDeleteByNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupDeleteByNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupDeleteByNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: GroupDeleteByNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/entity-look-up-request.schema.d.ts
interface EntityLookUpRequest {
  /**
   * ID of the alias.
   */
  alias_id?: string;
  /**
   * Accessor of the mount to which the alias belongs to. This should be supplied in conjunction with 'alias_name'.
   */
  alias_mount_accessor?: string;
  /**
   * Name of the alias. This should be supplied in conjunction with 'alias_mount_accessor'.
   */
  alias_name?: string;
  /**
   * ID of the entity.
   */
  id?: string;
  /**
   * Name of the entity.
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/entity-look-up.type.d.ts
interface EntityLookUpResponseBodies {
  200: void;
}
interface EntityLookUpRequestBodies {
  'application/json': EntityLookUpRequest;
}
type EntityLookUpRequestQuery = {};
type EntityLookUpRouteParameters = {};
type EntityLookUpRequestHeaders = {};
interface EntityLookUpParameterBodies {
  'application/json': EntityLookUpRequest & {
    [key: string]: any;
  };
}
type EntityLookUpRequestParameters = EntityLookUpRequestQuery & EntityLookUpRouteParameters & EntityLookUpRequestHeaders & EntityLookUpRequestBodies['application/json'];
interface EntityLookUpOperation<STATUS extends keyof EntityLookUpResponseBodies, CONTENT_TYPE extends keyof EntityLookUpParameterBodies> extends KeqOperation {
  requestParams: EntityLookUpRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EntityLookUpRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EntityLookUpRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EntityLookUpParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EntityLookUpResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/group-look-up-request.schema.d.ts
interface GroupLookUpRequest {
  /**
   * ID of the alias.
   */
  alias_id?: string;
  /**
   * Accessor of the mount to which the alias belongs to. This should be supplied in conjunction with 'alias_name'.
   */
  alias_mount_accessor?: string;
  /**
   * Name of the alias. This should be supplied in conjunction with 'alias_mount_accessor'.
   */
  alias_name?: string;
  /**
   * ID of the group.
   */
  id?: string;
  /**
   * Name of the group.
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/group-look-up.type.d.ts
interface GroupLookUpResponseBodies {
  200: void;
}
interface GroupLookUpRequestBodies {
  'application/json': GroupLookUpRequest;
}
type GroupLookUpRequestQuery = {};
type GroupLookUpRouteParameters = {};
type GroupLookUpRequestHeaders = {};
interface GroupLookUpParameterBodies {
  'application/json': GroupLookUpRequest & {
    [key: string]: any;
  };
}
type GroupLookUpRequestParameters = GroupLookUpRequestQuery & GroupLookUpRouteParameters & GroupLookUpRequestHeaders & GroupLookUpRequestBodies['application/json'];
interface GroupLookUpOperation<STATUS extends keyof GroupLookUpResponseBodies, CONTENT_TYPE extends keyof GroupLookUpParameterBodies> extends KeqOperation {
  requestParams: GroupLookUpRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GroupLookUpRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GroupLookUpRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GroupLookUpParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GroupLookUpResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-login-enforcements.type.d.ts
interface MfaListLoginEnforcementsResponseBodies {
  200: void;
}
type MfaListLoginEnforcementsRequestQuery = {
  list: ('true');
};
type MfaListLoginEnforcementsRouteParameters = {};
type MfaListLoginEnforcementsRequestHeaders = {};
type MfaListLoginEnforcementsRequestParameters = MfaListLoginEnforcementsRequestQuery & MfaListLoginEnforcementsRouteParameters & MfaListLoginEnforcementsRequestHeaders;
interface MfaListLoginEnforcementsOperation<STATUS extends keyof MfaListLoginEnforcementsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListLoginEnforcementsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListLoginEnforcementsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListLoginEnforcementsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListLoginEnforcementsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-login-enforcement.type.d.ts
interface MfaReadLoginEnforcementResponseBodies {
  200: void;
}
type MfaReadLoginEnforcementRequestQuery = {};
type MfaReadLoginEnforcementRouteParameters = {};
type MfaReadLoginEnforcementRequestHeaders = {};
type MfaReadLoginEnforcementRequestParameters = MfaReadLoginEnforcementRequestQuery & MfaReadLoginEnforcementRouteParameters & MfaReadLoginEnforcementRequestHeaders;
interface MfaReadLoginEnforcementOperation<STATUS extends keyof MfaReadLoginEnforcementResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadLoginEnforcementRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadLoginEnforcementRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadLoginEnforcementRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadLoginEnforcementResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-write-login-enforcement-request.schema.d.ts
interface MfaWriteLoginEnforcementRequest {
  /**
   * Array of auth mount accessor IDs
   */
  auth_method_accessors?: string[];
  /**
   * Array of auth mount types
   */
  auth_method_types?: string[];
  /**
   * Array of identity entity IDs
   */
  identity_entity_ids?: string[];
  /**
   * Array of identity group IDs
   */
  identity_group_ids?: string[];
  /**
   * Array of Method IDs that determine what methods will be enforced
   */
  mfa_method_ids: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-write-login-enforcement.type.d.ts
interface MfaWriteLoginEnforcementResponseBodies {
  200: void;
}
interface MfaWriteLoginEnforcementRequestBodies {
  'application/json': MfaWriteLoginEnforcementRequest;
}
type MfaWriteLoginEnforcementRequestQuery = {};
type MfaWriteLoginEnforcementRouteParameters = {};
type MfaWriteLoginEnforcementRequestHeaders = {};
interface MfaWriteLoginEnforcementParameterBodies {
  'application/json': MfaWriteLoginEnforcementRequest & {
    [key: string]: any;
  };
}
type MfaWriteLoginEnforcementRequestParameters = MfaWriteLoginEnforcementRequestQuery & MfaWriteLoginEnforcementRouteParameters & MfaWriteLoginEnforcementRequestHeaders & MfaWriteLoginEnforcementRequestBodies['application/json'];
interface MfaWriteLoginEnforcementOperation<STATUS extends keyof MfaWriteLoginEnforcementResponseBodies, CONTENT_TYPE extends keyof MfaWriteLoginEnforcementParameterBodies> extends KeqOperation {
  requestParams: MfaWriteLoginEnforcementRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaWriteLoginEnforcementRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaWriteLoginEnforcementRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaWriteLoginEnforcementParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaWriteLoginEnforcementResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-delete-login-enforcement.type.d.ts
interface MfaDeleteLoginEnforcementResponseBodies {
  204: void;
}
type MfaDeleteLoginEnforcementRequestQuery = {};
type MfaDeleteLoginEnforcementRouteParameters = {};
type MfaDeleteLoginEnforcementRequestHeaders = {};
type MfaDeleteLoginEnforcementRequestParameters = MfaDeleteLoginEnforcementRequestQuery & MfaDeleteLoginEnforcementRouteParameters & MfaDeleteLoginEnforcementRequestHeaders;
interface MfaDeleteLoginEnforcementOperation<STATUS extends keyof MfaDeleteLoginEnforcementResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaDeleteLoginEnforcementRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaDeleteLoginEnforcementRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaDeleteLoginEnforcementRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaDeleteLoginEnforcementResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-methods.type.d.ts
interface MfaListMethodsResponseBodies {
  200: void;
}
type MfaListMethodsRequestQuery = {
  list: ('true');
};
type MfaListMethodsRouteParameters = {};
type MfaListMethodsRequestHeaders = {};
type MfaListMethodsRequestParameters = MfaListMethodsRequestQuery & MfaListMethodsRouteParameters & MfaListMethodsRequestHeaders;
interface MfaListMethodsOperation<STATUS extends keyof MfaListMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-duo-methods.type.d.ts
interface MfaListDuoMethodsResponseBodies {
  200: void;
}
type MfaListDuoMethodsRequestQuery = {
  list: ('true');
};
type MfaListDuoMethodsRouteParameters = {};
type MfaListDuoMethodsRequestHeaders = {};
type MfaListDuoMethodsRequestParameters = MfaListDuoMethodsRequestQuery & MfaListDuoMethodsRouteParameters & MfaListDuoMethodsRequestHeaders;
interface MfaListDuoMethodsOperation<STATUS extends keyof MfaListDuoMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListDuoMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListDuoMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListDuoMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListDuoMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-duo-method-configuration.type.d.ts
interface MfaReadDuoMethodConfigurationResponseBodies {
  200: void;
}
type MfaReadDuoMethodConfigurationRequestQuery = {};
type MfaReadDuoMethodConfigurationRouteParameters = {};
type MfaReadDuoMethodConfigurationRequestHeaders = {};
type MfaReadDuoMethodConfigurationRequestParameters = MfaReadDuoMethodConfigurationRequestQuery & MfaReadDuoMethodConfigurationRouteParameters & MfaReadDuoMethodConfigurationRequestHeaders;
interface MfaReadDuoMethodConfigurationOperation<STATUS extends keyof MfaReadDuoMethodConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadDuoMethodConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadDuoMethodConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadDuoMethodConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadDuoMethodConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-configure-duo-method-request.schema.d.ts
interface MfaConfigureDuoMethodRequest {
  /**
   * API host name for Duo.
   */
  api_hostname?: string;
  /**
   * Integration key for Duo.
   */
  integration_key?: string;
  /**
   * The unique name identifier for this MFA method.
   */
  method_name?: string;
  /**
   * Push information for Duo.
   */
  push_info?: string;
  /**
   * Secret key for Duo.
   */
  secret_key?: string;
  /**
   * If true, the user is reminded to use the passcode upon MFA validation. This option does not enforce using the passcode. Defaults to false.
   */
  use_passcode?: boolean;
  /**
   * A template string for mapping Identity names to MFA method names. Values to subtitute should be placed in {{}}. For example, "{{alias.name}}@example.com". Currently-supported mappings: alias.name: The name returned by the mount configured via the mount_accessor parameter If blank, the Alias's name field will be used as-is.
   */
  username_format?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-configure-duo-method.type.d.ts
interface MfaConfigureDuoMethodResponseBodies {
  200: void;
}
interface MfaConfigureDuoMethodRequestBodies {
  'application/json': MfaConfigureDuoMethodRequest;
}
type MfaConfigureDuoMethodRequestQuery = {};
type MfaConfigureDuoMethodRouteParameters = {};
type MfaConfigureDuoMethodRequestHeaders = {};
interface MfaConfigureDuoMethodParameterBodies {
  'application/json': MfaConfigureDuoMethodRequest & {
    [key: string]: any;
  };
}
type MfaConfigureDuoMethodRequestParameters = MfaConfigureDuoMethodRequestQuery & MfaConfigureDuoMethodRouteParameters & MfaConfigureDuoMethodRequestHeaders & MfaConfigureDuoMethodRequestBodies['application/json'];
interface MfaConfigureDuoMethodOperation<STATUS extends keyof MfaConfigureDuoMethodResponseBodies, CONTENT_TYPE extends keyof MfaConfigureDuoMethodParameterBodies> extends KeqOperation {
  requestParams: MfaConfigureDuoMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaConfigureDuoMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaConfigureDuoMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaConfigureDuoMethodParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaConfigureDuoMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-delete-duo-method.type.d.ts
interface MfaDeleteDuoMethodResponseBodies {
  204: void;
}
type MfaDeleteDuoMethodRequestQuery = {};
type MfaDeleteDuoMethodRouteParameters = {};
type MfaDeleteDuoMethodRequestHeaders = {};
type MfaDeleteDuoMethodRequestParameters = MfaDeleteDuoMethodRequestQuery & MfaDeleteDuoMethodRouteParameters & MfaDeleteDuoMethodRequestHeaders;
interface MfaDeleteDuoMethodOperation<STATUS extends keyof MfaDeleteDuoMethodResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaDeleteDuoMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaDeleteDuoMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaDeleteDuoMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaDeleteDuoMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-okta-methods.type.d.ts
interface MfaListOktaMethodsResponseBodies {
  200: void;
}
type MfaListOktaMethodsRequestQuery = {
  list: ('true');
};
type MfaListOktaMethodsRouteParameters = {};
type MfaListOktaMethodsRequestHeaders = {};
type MfaListOktaMethodsRequestParameters = MfaListOktaMethodsRequestQuery & MfaListOktaMethodsRouteParameters & MfaListOktaMethodsRequestHeaders;
interface MfaListOktaMethodsOperation<STATUS extends keyof MfaListOktaMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListOktaMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListOktaMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListOktaMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListOktaMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-okta-method-configuration.type.d.ts
interface MfaReadOktaMethodConfigurationResponseBodies {
  200: void;
}
type MfaReadOktaMethodConfigurationRequestQuery = {};
type MfaReadOktaMethodConfigurationRouteParameters = {};
type MfaReadOktaMethodConfigurationRequestHeaders = {};
type MfaReadOktaMethodConfigurationRequestParameters = MfaReadOktaMethodConfigurationRequestQuery & MfaReadOktaMethodConfigurationRouteParameters & MfaReadOktaMethodConfigurationRequestHeaders;
interface MfaReadOktaMethodConfigurationOperation<STATUS extends keyof MfaReadOktaMethodConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadOktaMethodConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadOktaMethodConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadOktaMethodConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadOktaMethodConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-configure-okta-method-request.schema.d.ts
interface MfaConfigureOktaMethodRequest {
  /**
   * Okta API key.
   */
  api_token?: string;
  /**
   * The base domain to use for the Okta API. When not specified in the configuration, "okta.com" is used.
   */
  base_url?: string;
  /**
   * The unique name identifier for this MFA method.
   */
  method_name?: string;
  /**
   * Name of the organization to be used in the Okta API.
   */
  org_name?: string;
  /**
   * If true, the username will only match the primary email for the account. Defaults to false.
   */
  primary_email?: boolean;
  /**
   * (DEPRECATED) Use base_url instead.
   */
  production?: boolean;
  /**
   * A template string for mapping Identity names to MFA method names. Values to substitute should be placed in {{}}. For example, "{{entity.name}}@example.com". If blank, the Entity's name field will be used as-is.
   */
  username_format?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-configure-okta-method.type.d.ts
interface MfaConfigureOktaMethodResponseBodies {
  200: void;
}
interface MfaConfigureOktaMethodRequestBodies {
  'application/json': MfaConfigureOktaMethodRequest;
}
type MfaConfigureOktaMethodRequestQuery = {};
type MfaConfigureOktaMethodRouteParameters = {};
type MfaConfigureOktaMethodRequestHeaders = {};
interface MfaConfigureOktaMethodParameterBodies {
  'application/json': MfaConfigureOktaMethodRequest & {
    [key: string]: any;
  };
}
type MfaConfigureOktaMethodRequestParameters = MfaConfigureOktaMethodRequestQuery & MfaConfigureOktaMethodRouteParameters & MfaConfigureOktaMethodRequestHeaders & MfaConfigureOktaMethodRequestBodies['application/json'];
interface MfaConfigureOktaMethodOperation<STATUS extends keyof MfaConfigureOktaMethodResponseBodies, CONTENT_TYPE extends keyof MfaConfigureOktaMethodParameterBodies> extends KeqOperation {
  requestParams: MfaConfigureOktaMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaConfigureOktaMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaConfigureOktaMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaConfigureOktaMethodParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaConfigureOktaMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-delete-okta-method.type.d.ts
interface MfaDeleteOktaMethodResponseBodies {
  204: void;
}
type MfaDeleteOktaMethodRequestQuery = {};
type MfaDeleteOktaMethodRouteParameters = {};
type MfaDeleteOktaMethodRequestHeaders = {};
type MfaDeleteOktaMethodRequestParameters = MfaDeleteOktaMethodRequestQuery & MfaDeleteOktaMethodRouteParameters & MfaDeleteOktaMethodRequestHeaders;
interface MfaDeleteOktaMethodOperation<STATUS extends keyof MfaDeleteOktaMethodResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaDeleteOktaMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaDeleteOktaMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaDeleteOktaMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaDeleteOktaMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-ping-id-methods.type.d.ts
interface MfaListPingIdMethodsResponseBodies {
  200: void;
}
type MfaListPingIdMethodsRequestQuery = {
  list: ('true');
};
type MfaListPingIdMethodsRouteParameters = {};
type MfaListPingIdMethodsRequestHeaders = {};
type MfaListPingIdMethodsRequestParameters = MfaListPingIdMethodsRequestQuery & MfaListPingIdMethodsRouteParameters & MfaListPingIdMethodsRequestHeaders;
interface MfaListPingIdMethodsOperation<STATUS extends keyof MfaListPingIdMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListPingIdMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListPingIdMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListPingIdMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListPingIdMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-ping-id-method-configuration.type.d.ts
interface MfaReadPingIdMethodConfigurationResponseBodies {
  200: void;
}
type MfaReadPingIdMethodConfigurationRequestQuery = {};
type MfaReadPingIdMethodConfigurationRouteParameters = {};
type MfaReadPingIdMethodConfigurationRequestHeaders = {};
type MfaReadPingIdMethodConfigurationRequestParameters = MfaReadPingIdMethodConfigurationRequestQuery & MfaReadPingIdMethodConfigurationRouteParameters & MfaReadPingIdMethodConfigurationRequestHeaders;
interface MfaReadPingIdMethodConfigurationOperation<STATUS extends keyof MfaReadPingIdMethodConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadPingIdMethodConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadPingIdMethodConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadPingIdMethodConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadPingIdMethodConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-configure-ping-id-method-request.schema.d.ts
interface MfaConfigurePingIdMethodRequest {
  /**
   * The unique name identifier for this MFA method.
   */
  method_name?: string;
  /**
   * The settings file provided by Ping, Base64-encoded. This must be a settings file suitable for third-party clients, not the PingID SDK or PingFederate.
   */
  settings_file_base64?: string;
  /**
   * A template string for mapping Identity names to MFA method names. Values to subtitute should be placed in {{}}. For example, "{{alias.name}}@example.com". Currently-supported mappings: alias.name: The name returned by the mount configured via the mount_accessor parameter If blank, the Alias's name field will be used as-is.
   */
  username_format?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-configure-ping-id-method.type.d.ts
interface MfaConfigurePingIdMethodResponseBodies {
  200: void;
}
interface MfaConfigurePingIdMethodRequestBodies {
  'application/json': MfaConfigurePingIdMethodRequest;
}
type MfaConfigurePingIdMethodRequestQuery = {};
type MfaConfigurePingIdMethodRouteParameters = {};
type MfaConfigurePingIdMethodRequestHeaders = {};
interface MfaConfigurePingIdMethodParameterBodies {
  'application/json': MfaConfigurePingIdMethodRequest & {
    [key: string]: any;
  };
}
type MfaConfigurePingIdMethodRequestParameters = MfaConfigurePingIdMethodRequestQuery & MfaConfigurePingIdMethodRouteParameters & MfaConfigurePingIdMethodRequestHeaders & MfaConfigurePingIdMethodRequestBodies['application/json'];
interface MfaConfigurePingIdMethodOperation<STATUS extends keyof MfaConfigurePingIdMethodResponseBodies, CONTENT_TYPE extends keyof MfaConfigurePingIdMethodParameterBodies> extends KeqOperation {
  requestParams: MfaConfigurePingIdMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaConfigurePingIdMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaConfigurePingIdMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaConfigurePingIdMethodParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaConfigurePingIdMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-delete-ping-id-method.type.d.ts
interface MfaDeletePingIdMethodResponseBodies {
  204: void;
}
type MfaDeletePingIdMethodRequestQuery = {};
type MfaDeletePingIdMethodRouteParameters = {};
type MfaDeletePingIdMethodRequestHeaders = {};
type MfaDeletePingIdMethodRequestParameters = MfaDeletePingIdMethodRequestQuery & MfaDeletePingIdMethodRouteParameters & MfaDeletePingIdMethodRequestHeaders;
interface MfaDeletePingIdMethodOperation<STATUS extends keyof MfaDeletePingIdMethodResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaDeletePingIdMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaDeletePingIdMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaDeletePingIdMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaDeletePingIdMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-list-totp-methods.type.d.ts
interface MfaListTotpMethodsResponseBodies {
  200: void;
}
type MfaListTotpMethodsRequestQuery = {
  list: ('true');
};
type MfaListTotpMethodsRouteParameters = {};
type MfaListTotpMethodsRequestHeaders = {};
type MfaListTotpMethodsRequestParameters = MfaListTotpMethodsRequestQuery & MfaListTotpMethodsRouteParameters & MfaListTotpMethodsRequestHeaders;
interface MfaListTotpMethodsOperation<STATUS extends keyof MfaListTotpMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaListTotpMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaListTotpMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaListTotpMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaListTotpMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-admin-destroy-totp-secret-request.schema.d.ts
interface MfaAdminDestroyTotpSecretRequest {
  /**
   * Identifier of the entity from which the MFA method secret needs to be removed.
   */
  entity_id: string;
  /**
   * The unique identifier for this MFA method.
   */
  method_id: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-admin-destroy-totp-secret.type.d.ts
interface MfaAdminDestroyTotpSecretResponseBodies {
  200: void;
}
interface MfaAdminDestroyTotpSecretRequestBodies {
  'application/json': MfaAdminDestroyTotpSecretRequest;
}
type MfaAdminDestroyTotpSecretRequestQuery = {};
type MfaAdminDestroyTotpSecretRouteParameters = {};
type MfaAdminDestroyTotpSecretRequestHeaders = {};
interface MfaAdminDestroyTotpSecretParameterBodies {
  'application/json': MfaAdminDestroyTotpSecretRequest & {
    [key: string]: any;
  };
}
type MfaAdminDestroyTotpSecretRequestParameters = MfaAdminDestroyTotpSecretRequestQuery & MfaAdminDestroyTotpSecretRouteParameters & MfaAdminDestroyTotpSecretRequestHeaders & MfaAdminDestroyTotpSecretRequestBodies['application/json'];
interface MfaAdminDestroyTotpSecretOperation<STATUS extends keyof MfaAdminDestroyTotpSecretResponseBodies, CONTENT_TYPE extends keyof MfaAdminDestroyTotpSecretParameterBodies> extends KeqOperation {
  requestParams: MfaAdminDestroyTotpSecretRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaAdminDestroyTotpSecretRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaAdminDestroyTotpSecretRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaAdminDestroyTotpSecretParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaAdminDestroyTotpSecretResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-admin-generate-totp-secret-request.schema.d.ts
interface MfaAdminGenerateTotpSecretRequest {
  /**
   * Entity ID on which the generated secret needs to get stored.
   */
  entity_id: string;
  /**
   * The unique identifier for this MFA method.
   */
  method_id: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-admin-generate-totp-secret.type.d.ts
interface MfaAdminGenerateTotpSecretResponseBodies {
  200: void;
}
interface MfaAdminGenerateTotpSecretRequestBodies {
  'application/json': MfaAdminGenerateTotpSecretRequest;
}
type MfaAdminGenerateTotpSecretRequestQuery = {};
type MfaAdminGenerateTotpSecretRouteParameters = {};
type MfaAdminGenerateTotpSecretRequestHeaders = {};
interface MfaAdminGenerateTotpSecretParameterBodies {
  'application/json': MfaAdminGenerateTotpSecretRequest & {
    [key: string]: any;
  };
}
type MfaAdminGenerateTotpSecretRequestParameters = MfaAdminGenerateTotpSecretRequestQuery & MfaAdminGenerateTotpSecretRouteParameters & MfaAdminGenerateTotpSecretRequestHeaders & MfaAdminGenerateTotpSecretRequestBodies['application/json'];
interface MfaAdminGenerateTotpSecretOperation<STATUS extends keyof MfaAdminGenerateTotpSecretResponseBodies, CONTENT_TYPE extends keyof MfaAdminGenerateTotpSecretParameterBodies> extends KeqOperation {
  requestParams: MfaAdminGenerateTotpSecretRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaAdminGenerateTotpSecretRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaAdminGenerateTotpSecretRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaAdminGenerateTotpSecretParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaAdminGenerateTotpSecretResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-generate-totp-secret-request.schema.d.ts
interface MfaGenerateTotpSecretRequest {
  /**
   * The unique identifier for this MFA method.
   */
  method_id: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-generate-totp-secret.type.d.ts
interface MfaGenerateTotpSecretResponseBodies {
  200: void;
}
interface MfaGenerateTotpSecretRequestBodies {
  'application/json': MfaGenerateTotpSecretRequest;
}
type MfaGenerateTotpSecretRequestQuery = {};
type MfaGenerateTotpSecretRouteParameters = {};
type MfaGenerateTotpSecretRequestHeaders = {};
interface MfaGenerateTotpSecretParameterBodies {
  'application/json': MfaGenerateTotpSecretRequest & {
    [key: string]: any;
  };
}
type MfaGenerateTotpSecretRequestParameters = MfaGenerateTotpSecretRequestQuery & MfaGenerateTotpSecretRouteParameters & MfaGenerateTotpSecretRequestHeaders & MfaGenerateTotpSecretRequestBodies['application/json'];
interface MfaGenerateTotpSecretOperation<STATUS extends keyof MfaGenerateTotpSecretResponseBodies, CONTENT_TYPE extends keyof MfaGenerateTotpSecretParameterBodies> extends KeqOperation {
  requestParams: MfaGenerateTotpSecretRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaGenerateTotpSecretRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaGenerateTotpSecretRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaGenerateTotpSecretParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaGenerateTotpSecretResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-totp-method-configuration.type.d.ts
interface MfaReadTotpMethodConfigurationResponseBodies {
  200: void;
}
type MfaReadTotpMethodConfigurationRequestQuery = {};
type MfaReadTotpMethodConfigurationRouteParameters = {};
type MfaReadTotpMethodConfigurationRequestHeaders = {};
type MfaReadTotpMethodConfigurationRequestParameters = MfaReadTotpMethodConfigurationRequestQuery & MfaReadTotpMethodConfigurationRouteParameters & MfaReadTotpMethodConfigurationRequestHeaders;
interface MfaReadTotpMethodConfigurationOperation<STATUS extends keyof MfaReadTotpMethodConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadTotpMethodConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadTotpMethodConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadTotpMethodConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadTotpMethodConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-configure-totp-method-request.schema.d.ts
interface MfaConfigureTotpMethodRequest {
  /**
   * The hashing algorithm used to generate the TOTP token. Options include SHA1, SHA256 and SHA512.
   */
  algorithm?: string;
  /**
   * The number of digits in the generated TOTP token. This value can either be 6 or 8.
   */
  digits?: number;
  /**
   * The name of the key's issuing organization.
   */
  issuer?: string;
  /**
   * Determines the size in bytes of the generated key.
   */
  key_size?: number;
  /**
   * Max number of allowed validation attempts.
   */
  max_validation_attempts?: number;
  /**
   * The unique name identifier for this MFA method.
   */
  method_name?: string;
  /**
   * The length of time used to generate a counter for the TOTP token calculation.
   * @format seconds
   */
  period?: number;
  /**
   * The pixel size of the generated square QR code.
   */
  qr_size?: number;
  /**
   * The number of delay periods that are allowed when validating a TOTP token. This value can either be 0 or 1.
   */
  skew?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-configure-totp-method.type.d.ts
interface MfaConfigureTotpMethodResponseBodies {
  200: void;
}
interface MfaConfigureTotpMethodRequestBodies {
  'application/json': MfaConfigureTotpMethodRequest;
}
type MfaConfigureTotpMethodRequestQuery = {};
type MfaConfigureTotpMethodRouteParameters = {};
type MfaConfigureTotpMethodRequestHeaders = {};
interface MfaConfigureTotpMethodParameterBodies {
  'application/json': MfaConfigureTotpMethodRequest & {
    [key: string]: any;
  };
}
type MfaConfigureTotpMethodRequestParameters = MfaConfigureTotpMethodRequestQuery & MfaConfigureTotpMethodRouteParameters & MfaConfigureTotpMethodRequestHeaders & MfaConfigureTotpMethodRequestBodies['application/json'];
interface MfaConfigureTotpMethodOperation<STATUS extends keyof MfaConfigureTotpMethodResponseBodies, CONTENT_TYPE extends keyof MfaConfigureTotpMethodParameterBodies> extends KeqOperation {
  requestParams: MfaConfigureTotpMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaConfigureTotpMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaConfigureTotpMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaConfigureTotpMethodParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaConfigureTotpMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-delete-totp-method.type.d.ts
interface MfaDeleteTotpMethodResponseBodies {
  204: void;
}
type MfaDeleteTotpMethodRequestQuery = {};
type MfaDeleteTotpMethodRouteParameters = {};
type MfaDeleteTotpMethodRequestHeaders = {};
type MfaDeleteTotpMethodRequestParameters = MfaDeleteTotpMethodRequestQuery & MfaDeleteTotpMethodRouteParameters & MfaDeleteTotpMethodRequestHeaders;
interface MfaDeleteTotpMethodOperation<STATUS extends keyof MfaDeleteTotpMethodResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaDeleteTotpMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaDeleteTotpMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaDeleteTotpMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaDeleteTotpMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-read-method-configuration.type.d.ts
interface MfaReadMethodConfigurationResponseBodies {
  200: void;
}
type MfaReadMethodConfigurationRequestQuery = {};
type MfaReadMethodConfigurationRouteParameters = {};
type MfaReadMethodConfigurationRequestHeaders = {};
type MfaReadMethodConfigurationRequestParameters = MfaReadMethodConfigurationRequestQuery & MfaReadMethodConfigurationRouteParameters & MfaReadMethodConfigurationRequestHeaders;
interface MfaReadMethodConfigurationOperation<STATUS extends keyof MfaReadMethodConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MfaReadMethodConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaReadMethodConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaReadMethodConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MfaReadMethodConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-public-keys.type.d.ts
interface OidcReadPublicKeysResponseBodies {
  200: void;
}
type OidcReadPublicKeysRequestQuery = {};
type OidcReadPublicKeysRouteParameters = {};
type OidcReadPublicKeysRequestHeaders = {};
type OidcReadPublicKeysRequestParameters = OidcReadPublicKeysRequestQuery & OidcReadPublicKeysRouteParameters & OidcReadPublicKeysRequestHeaders;
interface OidcReadPublicKeysOperation<STATUS extends keyof OidcReadPublicKeysResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadPublicKeysRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadPublicKeysRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadPublicKeysRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadPublicKeysResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-open-id-configuration.type.d.ts
interface OidcReadOpenIdConfigurationResponseBodies {
  200: void;
}
type OidcReadOpenIdConfigurationRequestQuery = {};
type OidcReadOpenIdConfigurationRouteParameters = {};
type OidcReadOpenIdConfigurationRequestHeaders = {};
type OidcReadOpenIdConfigurationRequestParameters = OidcReadOpenIdConfigurationRequestQuery & OidcReadOpenIdConfigurationRouteParameters & OidcReadOpenIdConfigurationRequestHeaders;
interface OidcReadOpenIdConfigurationOperation<STATUS extends keyof OidcReadOpenIdConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadOpenIdConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadOpenIdConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadOpenIdConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadOpenIdConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-assignments.type.d.ts
interface OidcListAssignmentsResponseBodies {
  200: void;
}
type OidcListAssignmentsRequestQuery = {
  list: ('true');
};
type OidcListAssignmentsRouteParameters = {};
type OidcListAssignmentsRequestHeaders = {};
type OidcListAssignmentsRequestParameters = OidcListAssignmentsRequestQuery & OidcListAssignmentsRouteParameters & OidcListAssignmentsRequestHeaders;
interface OidcListAssignmentsOperation<STATUS extends keyof OidcListAssignmentsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListAssignmentsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListAssignmentsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListAssignmentsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListAssignmentsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-assignment.type.d.ts
interface OidcReadAssignmentResponseBodies {
  200: void;
}
type OidcReadAssignmentRequestQuery = {};
type OidcReadAssignmentRouteParameters = {};
type OidcReadAssignmentRequestHeaders = {};
type OidcReadAssignmentRequestParameters = OidcReadAssignmentRequestQuery & OidcReadAssignmentRouteParameters & OidcReadAssignmentRequestHeaders;
interface OidcReadAssignmentOperation<STATUS extends keyof OidcReadAssignmentResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadAssignmentRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadAssignmentRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadAssignmentRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadAssignmentResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-assignment-request.schema.d.ts
interface OidcWriteAssignmentRequest {
  /**
   * Comma separated string or array of identity entity IDs
   */
  entity_ids?: string[];
  /**
   * Comma separated string or array of identity group IDs
   */
  group_ids?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-assignment.type.d.ts
interface OidcWriteAssignmentResponseBodies {
  200: void;
}
interface OidcWriteAssignmentRequestBodies {
  'application/json': OidcWriteAssignmentRequest;
}
type OidcWriteAssignmentRequestQuery = {};
type OidcWriteAssignmentRouteParameters = {};
type OidcWriteAssignmentRequestHeaders = {};
interface OidcWriteAssignmentParameterBodies {
  'application/json': OidcWriteAssignmentRequest & {
    [key: string]: any;
  };
}
type OidcWriteAssignmentRequestParameters = OidcWriteAssignmentRequestQuery & OidcWriteAssignmentRouteParameters & OidcWriteAssignmentRequestHeaders & OidcWriteAssignmentRequestBodies['application/json'];
interface OidcWriteAssignmentOperation<STATUS extends keyof OidcWriteAssignmentResponseBodies, CONTENT_TYPE extends keyof OidcWriteAssignmentParameterBodies> extends KeqOperation {
  requestParams: OidcWriteAssignmentRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteAssignmentRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteAssignmentRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteAssignmentParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteAssignmentResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-assignment.type.d.ts
interface OidcDeleteAssignmentResponseBodies {
  204: void;
}
type OidcDeleteAssignmentRequestQuery = {};
type OidcDeleteAssignmentRouteParameters = {};
type OidcDeleteAssignmentRequestHeaders = {};
type OidcDeleteAssignmentRequestParameters = OidcDeleteAssignmentRequestQuery & OidcDeleteAssignmentRouteParameters & OidcDeleteAssignmentRequestHeaders;
interface OidcDeleteAssignmentOperation<STATUS extends keyof OidcDeleteAssignmentResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteAssignmentRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteAssignmentRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteAssignmentRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteAssignmentResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-clients.type.d.ts
interface OidcListClientsResponseBodies {
  200: void;
}
type OidcListClientsRequestQuery = {
  list: ('true');
};
type OidcListClientsRouteParameters = {};
type OidcListClientsRequestHeaders = {};
type OidcListClientsRequestParameters = OidcListClientsRequestQuery & OidcListClientsRouteParameters & OidcListClientsRequestHeaders;
interface OidcListClientsOperation<STATUS extends keyof OidcListClientsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListClientsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListClientsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListClientsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListClientsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-client.type.d.ts
interface OidcReadClientResponseBodies {
  200: void;
}
type OidcReadClientRequestQuery = {};
type OidcReadClientRouteParameters = {};
type OidcReadClientRequestHeaders = {};
type OidcReadClientRequestParameters = OidcReadClientRequestQuery & OidcReadClientRouteParameters & OidcReadClientRequestHeaders;
interface OidcReadClientOperation<STATUS extends keyof OidcReadClientResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadClientRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadClientRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadClientRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadClientResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-client-request.schema.d.ts
interface OidcWriteClientRequest {
  /**
   * The time-to-live for access tokens obtained by the client.
   * @format seconds
   */
  access_token_ttl?: number;
  /**
   * Comma separated string or array of assignment resources.
   */
  assignments?: string[];
  /**
   * Whether or not to authorization code flow is allowed in this provider
   */
  authorization_code?: boolean;
  /**
   * Whether or not to client credentials flow is allowed in this provider
   */
  client_credentials?: boolean;
  /**
   * The client type based on its ability to maintain confidentiality of credentials. The following client types are supported: 'confidential', 'public'. Defaults to 'confidential'.
   */
  client_type?: string;
  /**
   * The time-to-live for ID tokens obtained by the client.
   * @format seconds
   */
  id_token_ttl?: number;
  /**
   * A reference to a named key resource. Cannot be modified after creation. Defaults to the 'default' key.
   */
  key?: string;
  /**
   * Comma separated string or array of redirect URIs used by the client. One of these values must exactly match the redirect_uri parameter value used in each authentication request.
   */
  redirect_uris?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-client.type.d.ts
interface OidcWriteClientResponseBodies {
  200: void;
}
interface OidcWriteClientRequestBodies {
  'application/json': OidcWriteClientRequest;
}
type OidcWriteClientRequestQuery = {};
type OidcWriteClientRouteParameters = {};
type OidcWriteClientRequestHeaders = {};
interface OidcWriteClientParameterBodies {
  'application/json': OidcWriteClientRequest & {
    [key: string]: any;
  };
}
type OidcWriteClientRequestParameters = OidcWriteClientRequestQuery & OidcWriteClientRouteParameters & OidcWriteClientRequestHeaders & OidcWriteClientRequestBodies['application/json'];
interface OidcWriteClientOperation<STATUS extends keyof OidcWriteClientResponseBodies, CONTENT_TYPE extends keyof OidcWriteClientParameterBodies> extends KeqOperation {
  requestParams: OidcWriteClientRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteClientRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteClientRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteClientParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteClientResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-client.type.d.ts
interface OidcDeleteClientResponseBodies {
  204: void;
}
type OidcDeleteClientRequestQuery = {};
type OidcDeleteClientRouteParameters = {};
type OidcDeleteClientRequestHeaders = {};
type OidcDeleteClientRequestParameters = OidcDeleteClientRequestQuery & OidcDeleteClientRouteParameters & OidcDeleteClientRequestHeaders;
interface OidcDeleteClientOperation<STATUS extends keyof OidcDeleteClientResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteClientRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteClientRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteClientRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteClientResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-configuration.type.d.ts
interface OidcReadConfigurationResponseBodies {
  200: void;
}
type OidcReadConfigurationRequestQuery = {};
type OidcReadConfigurationRouteParameters = {};
type OidcReadConfigurationRequestHeaders = {};
type OidcReadConfigurationRequestParameters = OidcReadConfigurationRequestQuery & OidcReadConfigurationRouteParameters & OidcReadConfigurationRequestHeaders;
interface OidcReadConfigurationOperation<STATUS extends keyof OidcReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-configure-request.schema.d.ts
interface OidcConfigureRequest {
  /**
   * Issuer URL to be used in the iss claim of the token. If not set, OpenBao's app_addr will be used.
   */
  issuer?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-configure.type.d.ts
interface OidcConfigureResponseBodies {
  200: void;
}
interface OidcConfigureRequestBodies {
  'application/json': OidcConfigureRequest;
}
type OidcConfigureRequestQuery = {};
type OidcConfigureRouteParameters = {};
type OidcConfigureRequestHeaders = {};
interface OidcConfigureParameterBodies {
  'application/json': OidcConfigureRequest & {
    [key: string]: any;
  };
}
type OidcConfigureRequestParameters = OidcConfigureRequestQuery & OidcConfigureRouteParameters & OidcConfigureRequestHeaders & OidcConfigureRequestBodies['application/json'];
interface OidcConfigureOperation<STATUS extends keyof OidcConfigureResponseBodies, CONTENT_TYPE extends keyof OidcConfigureParameterBodies> extends KeqOperation {
  requestParams: OidcConfigureRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcConfigureRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcConfigureRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcConfigureParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcConfigureResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-introspect-request.schema.d.ts
interface OidcIntrospectRequest {
  /**
   * Optional client_id to verify
   */
  client_id?: string;
  /**
   * Token to verify
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-introspect.type.d.ts
interface OidcIntrospectResponseBodies {
  200: void;
}
interface OidcIntrospectRequestBodies {
  'application/json': OidcIntrospectRequest;
}
type OidcIntrospectRequestQuery = {};
type OidcIntrospectRouteParameters = {};
type OidcIntrospectRequestHeaders = {};
interface OidcIntrospectParameterBodies {
  'application/json': OidcIntrospectRequest & {
    [key: string]: any;
  };
}
type OidcIntrospectRequestParameters = OidcIntrospectRequestQuery & OidcIntrospectRouteParameters & OidcIntrospectRequestHeaders & OidcIntrospectRequestBodies['application/json'];
interface OidcIntrospectOperation<STATUS extends keyof OidcIntrospectResponseBodies, CONTENT_TYPE extends keyof OidcIntrospectParameterBodies> extends KeqOperation {
  requestParams: OidcIntrospectRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcIntrospectRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcIntrospectRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcIntrospectParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcIntrospectResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-keys.type.d.ts
interface OidcListKeysResponseBodies {
  200: void;
}
type OidcListKeysRequestQuery = {
  list: ('true');
};
type OidcListKeysRouteParameters = {};
type OidcListKeysRequestHeaders = {};
type OidcListKeysRequestParameters = OidcListKeysRequestQuery & OidcListKeysRouteParameters & OidcListKeysRequestHeaders;
interface OidcListKeysOperation<STATUS extends keyof OidcListKeysResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListKeysRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListKeysRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListKeysRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListKeysResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-key.type.d.ts
interface OidcReadKeyResponseBodies {
  200: void;
}
type OidcReadKeyRequestQuery = {};
type OidcReadKeyRouteParameters = {};
type OidcReadKeyRequestHeaders = {};
type OidcReadKeyRequestParameters = OidcReadKeyRequestQuery & OidcReadKeyRouteParameters & OidcReadKeyRequestHeaders;
interface OidcReadKeyOperation<STATUS extends keyof OidcReadKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-key-request.schema.d.ts
interface OidcWriteKeyRequest {
  /**
   * Signing algorithm to use. This will default to RS256.
   */
  algorithm?: string;
  /**
   * Comma separated string or array of role client ids allowed to use this key for signing. If empty no roles are allowed. If "*" all roles are allowed.
   */
  allowed_client_ids?: string[];
  /**
   * How often to generate a new keypair.
   * @format seconds
   */
  rotation_period?: number;
  /**
   * Controls how long the public portion of a key will be available for verification after being rotated.
   * @format seconds
   */
  verification_ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-key.type.d.ts
interface OidcWriteKeyResponseBodies {
  200: void;
}
interface OidcWriteKeyRequestBodies {
  'application/json': OidcWriteKeyRequest;
}
type OidcWriteKeyRequestQuery = {};
type OidcWriteKeyRouteParameters = {};
type OidcWriteKeyRequestHeaders = {};
interface OidcWriteKeyParameterBodies {
  'application/json': OidcWriteKeyRequest & {
    [key: string]: any;
  };
}
type OidcWriteKeyRequestParameters = OidcWriteKeyRequestQuery & OidcWriteKeyRouteParameters & OidcWriteKeyRequestHeaders & OidcWriteKeyRequestBodies['application/json'];
interface OidcWriteKeyOperation<STATUS extends keyof OidcWriteKeyResponseBodies, CONTENT_TYPE extends keyof OidcWriteKeyParameterBodies> extends KeqOperation {
  requestParams: OidcWriteKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-key.type.d.ts
interface OidcDeleteKeyResponseBodies {
  204: void;
}
type OidcDeleteKeyRequestQuery = {};
type OidcDeleteKeyRouteParameters = {};
type OidcDeleteKeyRequestHeaders = {};
type OidcDeleteKeyRequestParameters = OidcDeleteKeyRequestQuery & OidcDeleteKeyRouteParameters & OidcDeleteKeyRequestHeaders;
interface OidcDeleteKeyOperation<STATUS extends keyof OidcDeleteKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-rotate-key-request.schema.d.ts
interface OidcRotateKeyRequest {
  /**
   * Controls how long the public portion of a key will be available for verification after being rotated. Setting verification_ttl here will override the verification_ttl set on the key.
   * @format seconds
   */
  verification_ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-rotate-key.type.d.ts
interface OidcRotateKeyResponseBodies {
  200: void;
}
interface OidcRotateKeyRequestBodies {
  'application/json': OidcRotateKeyRequest;
}
type OidcRotateKeyRequestQuery = {};
type OidcRotateKeyRouteParameters = {};
type OidcRotateKeyRequestHeaders = {};
interface OidcRotateKeyParameterBodies {
  'application/json': OidcRotateKeyRequest & {
    [key: string]: any;
  };
}
type OidcRotateKeyRequestParameters = OidcRotateKeyRequestQuery & OidcRotateKeyRouteParameters & OidcRotateKeyRequestHeaders & OidcRotateKeyRequestBodies['application/json'];
interface OidcRotateKeyOperation<STATUS extends keyof OidcRotateKeyResponseBodies, CONTENT_TYPE extends keyof OidcRotateKeyParameterBodies> extends KeqOperation {
  requestParams: OidcRotateKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcRotateKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcRotateKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcRotateKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcRotateKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-providers.type.d.ts
interface OidcListProvidersResponseBodies {
  200: void;
}
type OidcListProvidersRequestQuery = {
  list: ('true');
};
type OidcListProvidersRouteParameters = {};
type OidcListProvidersRequestHeaders = {};
type OidcListProvidersRequestParameters = OidcListProvidersRequestQuery & OidcListProvidersRouteParameters & OidcListProvidersRequestHeaders;
interface OidcListProvidersOperation<STATUS extends keyof OidcListProvidersResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListProvidersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListProvidersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListProvidersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListProvidersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-provider.type.d.ts
interface OidcReadProviderResponseBodies {
  200: void;
}
type OidcReadProviderRequestQuery = {};
type OidcReadProviderRouteParameters = {};
type OidcReadProviderRequestHeaders = {};
type OidcReadProviderRequestParameters = OidcReadProviderRequestQuery & OidcReadProviderRouteParameters & OidcReadProviderRequestHeaders;
interface OidcReadProviderOperation<STATUS extends keyof OidcReadProviderResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadProviderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadProviderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadProviderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadProviderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-provider-request.schema.d.ts
interface OidcWriteProviderRequest {
  /**
   * The client IDs that are permitted to use the provider
   */
  allowed_client_ids?: string[];
  /**
   * Specifies what will be used for the iss claim of ID tokens.
   */
  issuer?: string;
  /**
   * The scopes supported for requesting on the provider
   */
  scopes_supported?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-provider.type.d.ts
interface OidcWriteProviderResponseBodies {
  200: void;
}
interface OidcWriteProviderRequestBodies {
  'application/json': OidcWriteProviderRequest;
}
type OidcWriteProviderRequestQuery = {};
type OidcWriteProviderRouteParameters = {};
type OidcWriteProviderRequestHeaders = {};
interface OidcWriteProviderParameterBodies {
  'application/json': OidcWriteProviderRequest & {
    [key: string]: any;
  };
}
type OidcWriteProviderRequestParameters = OidcWriteProviderRequestQuery & OidcWriteProviderRouteParameters & OidcWriteProviderRequestHeaders & OidcWriteProviderRequestBodies['application/json'];
interface OidcWriteProviderOperation<STATUS extends keyof OidcWriteProviderResponseBodies, CONTENT_TYPE extends keyof OidcWriteProviderParameterBodies> extends KeqOperation {
  requestParams: OidcWriteProviderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteProviderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteProviderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteProviderParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteProviderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-provider.type.d.ts
interface OidcDeleteProviderResponseBodies {
  204: void;
}
type OidcDeleteProviderRequestQuery = {};
type OidcDeleteProviderRouteParameters = {};
type OidcDeleteProviderRequestHeaders = {};
type OidcDeleteProviderRequestParameters = OidcDeleteProviderRequestQuery & OidcDeleteProviderRouteParameters & OidcDeleteProviderRequestHeaders;
interface OidcDeleteProviderOperation<STATUS extends keyof OidcDeleteProviderResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteProviderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteProviderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteProviderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteProviderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-provider-public-keys.type.d.ts
interface OidcReadProviderPublicKeysResponseBodies {
  200: void;
}
type OidcReadProviderPublicKeysRequestQuery = {};
type OidcReadProviderPublicKeysRouteParameters = {};
type OidcReadProviderPublicKeysRequestHeaders = {};
type OidcReadProviderPublicKeysRequestParameters = OidcReadProviderPublicKeysRequestQuery & OidcReadProviderPublicKeysRouteParameters & OidcReadProviderPublicKeysRequestHeaders;
interface OidcReadProviderPublicKeysOperation<STATUS extends keyof OidcReadProviderPublicKeysResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadProviderPublicKeysRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadProviderPublicKeysRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadProviderPublicKeysRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadProviderPublicKeysResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-provider-open-id-configuration.type.d.ts
interface OidcReadProviderOpenIdConfigurationResponseBodies {
  200: void;
}
type OidcReadProviderOpenIdConfigurationRequestQuery = {};
type OidcReadProviderOpenIdConfigurationRouteParameters = {};
type OidcReadProviderOpenIdConfigurationRequestHeaders = {};
type OidcReadProviderOpenIdConfigurationRequestParameters = OidcReadProviderOpenIdConfigurationRequestQuery & OidcReadProviderOpenIdConfigurationRouteParameters & OidcReadProviderOpenIdConfigurationRequestHeaders;
interface OidcReadProviderOpenIdConfigurationOperation<STATUS extends keyof OidcReadProviderOpenIdConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadProviderOpenIdConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadProviderOpenIdConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadProviderOpenIdConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadProviderOpenIdConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-provider-authorize.type.d.ts
interface OidcProviderAuthorizeResponseBodies {
  200: void;
}
type OidcProviderAuthorizeRequestQuery = {};
type OidcProviderAuthorizeRouteParameters = {};
type OidcProviderAuthorizeRequestHeaders = {};
type OidcProviderAuthorizeRequestParameters = OidcProviderAuthorizeRequestQuery & OidcProviderAuthorizeRouteParameters & OidcProviderAuthorizeRequestHeaders;
interface OidcProviderAuthorizeOperation<STATUS extends keyof OidcProviderAuthorizeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcProviderAuthorizeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcProviderAuthorizeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcProviderAuthorizeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcProviderAuthorizeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-provider-authorize-with-parameters-request.schema.d.ts
interface OidcProviderAuthorizeWithParametersRequest {
  /**
   * The ID of the requesting client.
   */
  client_id: string;
  /**
   * The code challenge derived from the code verifier.
   */
  code_challenge?: string;
  /**
   * The method that was used to derive the code challenge. The following methods are supported: 'S256', 'plain'. Defaults to 'plain'.
   */
  code_challenge_method?: string;
  /**
   * The allowable elapsed time in seconds since the last time the end-user was actively authenticated.
   */
  max_age?: number;
  /**
   * The value that will be returned in the ID token nonce claim after a token exchange.
   */
  nonce?: string;
  /**
   * The redirection URI to which the response will be sent.
   */
  redirect_uri: string;
  /**
   * The OIDC authentication flow to be used. The following response types are supported: 'code'
   */
  response_type: string;
  /**
   * A space-delimited, case-sensitive list of scopes to be requested. The 'openid' scope is required.
   */
  scope: string;
  /**
   * The value used to maintain state between the authentication request and client.
   */
  state?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-provider-authorize-with-parameters.type.d.ts
interface OidcProviderAuthorizeWithParametersResponseBodies {
  200: void;
}
interface OidcProviderAuthorizeWithParametersRequestBodies {
  'application/json': OidcProviderAuthorizeWithParametersRequest;
}
type OidcProviderAuthorizeWithParametersRequestQuery = {};
type OidcProviderAuthorizeWithParametersRouteParameters = {};
type OidcProviderAuthorizeWithParametersRequestHeaders = {};
interface OidcProviderAuthorizeWithParametersParameterBodies {
  'application/json': OidcProviderAuthorizeWithParametersRequest & {
    [key: string]: any;
  };
}
type OidcProviderAuthorizeWithParametersRequestParameters = OidcProviderAuthorizeWithParametersRequestQuery & OidcProviderAuthorizeWithParametersRouteParameters & OidcProviderAuthorizeWithParametersRequestHeaders & OidcProviderAuthorizeWithParametersRequestBodies['application/json'];
interface OidcProviderAuthorizeWithParametersOperation<STATUS extends keyof OidcProviderAuthorizeWithParametersResponseBodies, CONTENT_TYPE extends keyof OidcProviderAuthorizeWithParametersParameterBodies> extends KeqOperation {
  requestParams: OidcProviderAuthorizeWithParametersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcProviderAuthorizeWithParametersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcProviderAuthorizeWithParametersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcProviderAuthorizeWithParametersParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcProviderAuthorizeWithParametersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-provider-token-request.schema.d.ts
interface OidcProviderTokenRequest {
  /**
   * The ID of the requesting client.
   */
  client_id?: string;
  /**
   * The secret of the requesting client.
   */
  client_secret?: string;
  /**
   * The authorization code received from the provider's authorization endpoint.
   */
  code: string;
  /**
   * The code verifier associated with the authorization code.
   */
  code_verifier?: string;
  /**
   * The authorization grant type. The following grant types are supported: 'authorization_code','client_credentials'.
   */
  grant_type: string;
  /**
   * The callback location where the authentication response was sent.
   */
  redirect_uri: string;
  /**
   * A space-delimited, case-sensitive list of scopes to be requested. The 'openid' scope is required. This is used when using in with 'client_credentials' flow
   */
  scope: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-provider-token.type.d.ts
interface OidcProviderTokenResponseBodies {
  200: void;
}
interface OidcProviderTokenRequestBodies {
  'application/json': OidcProviderTokenRequest;
}
type OidcProviderTokenRequestQuery = {};
type OidcProviderTokenRouteParameters = {};
type OidcProviderTokenRequestHeaders = {};
interface OidcProviderTokenParameterBodies {
  'application/json': OidcProviderTokenRequest & {
    [key: string]: any;
  };
}
type OidcProviderTokenRequestParameters = OidcProviderTokenRequestQuery & OidcProviderTokenRouteParameters & OidcProviderTokenRequestHeaders & OidcProviderTokenRequestBodies['application/json'];
interface OidcProviderTokenOperation<STATUS extends keyof OidcProviderTokenResponseBodies, CONTENT_TYPE extends keyof OidcProviderTokenParameterBodies> extends KeqOperation {
  requestParams: OidcProviderTokenRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcProviderTokenRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcProviderTokenRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcProviderTokenParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcProviderTokenResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-provider-user-info.type.d.ts
interface OidcProviderUserInfoResponseBodies {
  200: void;
}
type OidcProviderUserInfoRequestQuery = {};
type OidcProviderUserInfoRouteParameters = {};
type OidcProviderUserInfoRequestHeaders = {};
type OidcProviderUserInfoRequestParameters = OidcProviderUserInfoRequestQuery & OidcProviderUserInfoRouteParameters & OidcProviderUserInfoRequestHeaders;
interface OidcProviderUserInfoOperation<STATUS extends keyof OidcProviderUserInfoResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcProviderUserInfoRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcProviderUserInfoRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcProviderUserInfoRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcProviderUserInfoResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-roles.type.d.ts
interface OidcListRolesResponseBodies {
  200: void;
}
type OidcListRolesRequestQuery = {
  list: ('true');
};
type OidcListRolesRouteParameters = {};
type OidcListRolesRequestHeaders = {};
type OidcListRolesRequestParameters = OidcListRolesRequestQuery & OidcListRolesRouteParameters & OidcListRolesRequestHeaders;
interface OidcListRolesOperation<STATUS extends keyof OidcListRolesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListRolesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListRolesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListRolesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListRolesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-role.type.d.ts
interface OidcReadRoleResponseBodies {
  200: void;
}
type OidcReadRoleRequestQuery = {};
type OidcReadRoleRouteParameters = {};
type OidcReadRoleRequestHeaders = {};
type OidcReadRoleRequestParameters = OidcReadRoleRequestQuery & OidcReadRoleRouteParameters & OidcReadRoleRequestHeaders;
interface OidcReadRoleOperation<STATUS extends keyof OidcReadRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-role-request.schema.d.ts
interface OidcWriteRoleRequest {
  /**
   * Optional client_id
   */
  client_id?: string;
  /**
   * The OIDC key to use for generating tokens. The specified key must already exist.
   */
  key: string;
  /**
   * The template string to use for generating tokens. This may be in string-ified JSON or base64 format.
   */
  template?: string;
  /**
   * TTL of the tokens generated against the role.
   * @format seconds
   */
  ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-role.type.d.ts
interface OidcWriteRoleResponseBodies {
  200: void;
}
interface OidcWriteRoleRequestBodies {
  'application/json': OidcWriteRoleRequest;
}
type OidcWriteRoleRequestQuery = {};
type OidcWriteRoleRouteParameters = {};
type OidcWriteRoleRequestHeaders = {};
interface OidcWriteRoleParameterBodies {
  'application/json': OidcWriteRoleRequest & {
    [key: string]: any;
  };
}
type OidcWriteRoleRequestParameters = OidcWriteRoleRequestQuery & OidcWriteRoleRouteParameters & OidcWriteRoleRequestHeaders & OidcWriteRoleRequestBodies['application/json'];
interface OidcWriteRoleOperation<STATUS extends keyof OidcWriteRoleResponseBodies, CONTENT_TYPE extends keyof OidcWriteRoleParameterBodies> extends KeqOperation {
  requestParams: OidcWriteRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteRoleParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-role.type.d.ts
interface OidcDeleteRoleResponseBodies {
  204: void;
}
type OidcDeleteRoleRequestQuery = {};
type OidcDeleteRoleRouteParameters = {};
type OidcDeleteRoleRequestHeaders = {};
type OidcDeleteRoleRequestParameters = OidcDeleteRoleRequestQuery & OidcDeleteRoleRouteParameters & OidcDeleteRoleRequestHeaders;
interface OidcDeleteRoleOperation<STATUS extends keyof OidcDeleteRoleResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteRoleRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteRoleRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteRoleRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteRoleResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-list-scopes.type.d.ts
interface OidcListScopesResponseBodies {
  200: void;
}
type OidcListScopesRequestQuery = {
  list: ('true');
};
type OidcListScopesRouteParameters = {};
type OidcListScopesRequestHeaders = {};
type OidcListScopesRequestParameters = OidcListScopesRequestQuery & OidcListScopesRouteParameters & OidcListScopesRequestHeaders;
interface OidcListScopesOperation<STATUS extends keyof OidcListScopesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcListScopesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcListScopesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcListScopesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcListScopesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-read-scope.type.d.ts
interface OidcReadScopeResponseBodies {
  200: void;
}
type OidcReadScopeRequestQuery = {};
type OidcReadScopeRouteParameters = {};
type OidcReadScopeRequestHeaders = {};
type OidcReadScopeRequestParameters = OidcReadScopeRequestQuery & OidcReadScopeRouteParameters & OidcReadScopeRequestHeaders;
interface OidcReadScopeOperation<STATUS extends keyof OidcReadScopeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcReadScopeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcReadScopeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcReadScopeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcReadScopeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/oidc-write-scope-request.schema.d.ts
interface OidcWriteScopeRequest {
  /**
   * The description of the scope
   */
  description?: string;
  /**
   * The template string to use for the scope. This may be in string-ified JSON or base64 format.
   */
  template?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-write-scope.type.d.ts
interface OidcWriteScopeResponseBodies {
  200: void;
}
interface OidcWriteScopeRequestBodies {
  'application/json': OidcWriteScopeRequest;
}
type OidcWriteScopeRequestQuery = {};
type OidcWriteScopeRouteParameters = {};
type OidcWriteScopeRequestHeaders = {};
interface OidcWriteScopeParameterBodies {
  'application/json': OidcWriteScopeRequest & {
    [key: string]: any;
  };
}
type OidcWriteScopeRequestParameters = OidcWriteScopeRequestQuery & OidcWriteScopeRouteParameters & OidcWriteScopeRequestHeaders & OidcWriteScopeRequestBodies['application/json'];
interface OidcWriteScopeOperation<STATUS extends keyof OidcWriteScopeResponseBodies, CONTENT_TYPE extends keyof OidcWriteScopeParameterBodies> extends KeqOperation {
  requestParams: OidcWriteScopeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcWriteScopeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcWriteScopeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: OidcWriteScopeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: OidcWriteScopeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-delete-scope.type.d.ts
interface OidcDeleteScopeResponseBodies {
  204: void;
}
type OidcDeleteScopeRequestQuery = {};
type OidcDeleteScopeRouteParameters = {};
type OidcDeleteScopeRequestHeaders = {};
type OidcDeleteScopeRequestParameters = OidcDeleteScopeRequestQuery & OidcDeleteScopeRouteParameters & OidcDeleteScopeRequestHeaders;
interface OidcDeleteScopeOperation<STATUS extends keyof OidcDeleteScopeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcDeleteScopeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcDeleteScopeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcDeleteScopeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcDeleteScopeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/oidc-generate-token.type.d.ts
interface OidcGenerateTokenResponseBodies {
  200: void;
}
type OidcGenerateTokenRequestQuery = {};
type OidcGenerateTokenRouteParameters = {};
type OidcGenerateTokenRequestHeaders = {};
type OidcGenerateTokenRequestParameters = OidcGenerateTokenRequestQuery & OidcGenerateTokenRouteParameters & OidcGenerateTokenRequestHeaders;
interface OidcGenerateTokenOperation<STATUS extends keyof OidcGenerateTokenResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: OidcGenerateTokenRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: OidcGenerateTokenRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: OidcGenerateTokenRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: OidcGenerateTokenResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/persona-create-request.schema.d.ts
interface PersonaCreateRequest {
  /**
   * Entity ID to which this persona belongs to
   */
  entity_id?: string;
  /**
   * ID of the persona
   */
  id?: string;
  /**
   * Metadata to be associated with the persona. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Mount accessor to which this persona belongs to
   */
  mount_accessor?: string;
  /**
   * Name of the persona
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/persona-create.type.d.ts
interface PersonaCreateResponseBodies {
  200: void;
}
interface PersonaCreateRequestBodies {
  'application/json': PersonaCreateRequest;
}
type PersonaCreateRequestQuery = {};
type PersonaCreateRouteParameters = {};
type PersonaCreateRequestHeaders = {};
interface PersonaCreateParameterBodies {
  'application/json': PersonaCreateRequest & {
    [key: string]: any;
  };
}
type PersonaCreateRequestParameters = PersonaCreateRequestQuery & PersonaCreateRouteParameters & PersonaCreateRequestHeaders & PersonaCreateRequestBodies['application/json'];
interface PersonaCreateOperation<STATUS extends keyof PersonaCreateResponseBodies, CONTENT_TYPE extends keyof PersonaCreateParameterBodies> extends KeqOperation {
  requestParams: PersonaCreateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PersonaCreateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PersonaCreateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PersonaCreateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PersonaCreateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/persona-list-by-id.type.d.ts
interface PersonaListByIdResponseBodies {
  200: void;
}
type PersonaListByIdRequestQuery = {
  list: ('true');
};
type PersonaListByIdRouteParameters = {};
type PersonaListByIdRequestHeaders = {};
type PersonaListByIdRequestParameters = PersonaListByIdRequestQuery & PersonaListByIdRouteParameters & PersonaListByIdRequestHeaders;
interface PersonaListByIdOperation<STATUS extends keyof PersonaListByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PersonaListByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PersonaListByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PersonaListByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PersonaListByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/persona-read-by-id.type.d.ts
interface PersonaReadByIdResponseBodies {
  200: void;
}
type PersonaReadByIdRequestQuery = {};
type PersonaReadByIdRouteParameters = {};
type PersonaReadByIdRequestHeaders = {};
type PersonaReadByIdRequestParameters = PersonaReadByIdRequestQuery & PersonaReadByIdRouteParameters & PersonaReadByIdRequestHeaders;
interface PersonaReadByIdOperation<STATUS extends keyof PersonaReadByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PersonaReadByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PersonaReadByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PersonaReadByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PersonaReadByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/persona-update-by-id-request.schema.d.ts
interface PersonaUpdateByIdRequest {
  /**
   * Entity ID to which this persona should be tied to
   */
  entity_id?: string;
  /**
   * Metadata to be associated with the persona. In CLI, this parameter can be repeated multiple times, and it all gets merged together. For example: bao <command> <path> metadata=key1=value1 metadata=key2=value2
   * @format kvpairs
   */
  metadata?: Record<string, never>;
  /**
   * Mount accessor to which this persona belongs to
   */
  mount_accessor?: string;
  /**
   * Name of the persona
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/persona-update-by-id.type.d.ts
interface PersonaUpdateByIdResponseBodies {
  200: void;
}
interface PersonaUpdateByIdRequestBodies {
  'application/json': PersonaUpdateByIdRequest;
}
type PersonaUpdateByIdRequestQuery = {};
type PersonaUpdateByIdRouteParameters = {};
type PersonaUpdateByIdRequestHeaders = {};
interface PersonaUpdateByIdParameterBodies {
  'application/json': PersonaUpdateByIdRequest & {
    [key: string]: any;
  };
}
type PersonaUpdateByIdRequestParameters = PersonaUpdateByIdRequestQuery & PersonaUpdateByIdRouteParameters & PersonaUpdateByIdRequestHeaders & PersonaUpdateByIdRequestBodies['application/json'];
interface PersonaUpdateByIdOperation<STATUS extends keyof PersonaUpdateByIdResponseBodies, CONTENT_TYPE extends keyof PersonaUpdateByIdParameterBodies> extends KeqOperation {
  requestParams: PersonaUpdateByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PersonaUpdateByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PersonaUpdateByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PersonaUpdateByIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PersonaUpdateByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/persona-delete-by-id.type.d.ts
interface PersonaDeleteByIdResponseBodies {
  204: void;
}
type PersonaDeleteByIdRequestQuery = {};
type PersonaDeleteByIdRouteParameters = {};
type PersonaDeleteByIdRequestHeaders = {};
type PersonaDeleteByIdRequestParameters = PersonaDeleteByIdRequestQuery & PersonaDeleteByIdRouteParameters & PersonaDeleteByIdRequestHeaders;
interface PersonaDeleteByIdOperation<STATUS extends keyof PersonaDeleteByIdResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PersonaDeleteByIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PersonaDeleteByIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PersonaDeleteByIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PersonaDeleteByIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-read-config.type.d.ts
interface KvReadConfigResponseBodies {
  200: void;
}
type KvReadConfigRequestQuery = {};
type KvReadConfigRouteParameters = {};
type KvReadConfigRequestHeaders = {};
type KvReadConfigRequestParameters = KvReadConfigRequestQuery & KvReadConfigRouteParameters & KvReadConfigRequestHeaders;
interface KvReadConfigOperation<STATUS extends keyof KvReadConfigResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvReadConfigRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvReadConfigRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvReadConfigRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvReadConfigResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-config-request.schema.d.ts
interface KvWriteConfigRequest {
  /**
   * If true, the backend will require the cas parameter to be set for each write
   */
  cas_required?: boolean;
  /**
   * If set, the length of time before a version is deleted. A negative duration disables the use of delete_version_after on all keys. A zero duration clears the current setting. Accepts a Go duration format string.
   * @format seconds
   */
  delete_version_after?: number;
  /**
   * The number of versions to keep for each key. Defaults to 10
   */
  max_versions?: number;
  /**
   * If true, the backend will require the metadata_cas parameter to be set for each metadata update
   */
  metadata_cas_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-config.type.d.ts
interface KvWriteConfigResponseBodies {
  200: void;
}
interface KvWriteConfigRequestBodies {
  'application/json': KvWriteConfigRequest;
}
type KvWriteConfigRequestQuery = {};
type KvWriteConfigRouteParameters = {};
type KvWriteConfigRequestHeaders = {};
interface KvWriteConfigParameterBodies {
  'application/json': KvWriteConfigRequest & {
    [key: string]: any;
  };
}
type KvWriteConfigRequestParameters = KvWriteConfigRequestQuery & KvWriteConfigRouteParameters & KvWriteConfigRequestHeaders & KvWriteConfigRequestBodies['application/json'];
interface KvWriteConfigOperation<STATUS extends keyof KvWriteConfigResponseBodies, CONTENT_TYPE extends keyof KvWriteConfigParameterBodies> extends KeqOperation {
  requestParams: KvWriteConfigRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteConfigRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteConfigRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteConfigParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteConfigResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-read-data-path.type.d.ts
interface KvReadDataPathResponseBodies {
  200: void;
}
type KvReadDataPathRequestQuery = {};
type KvReadDataPathRouteParameters = {};
type KvReadDataPathRequestHeaders = {};
type KvReadDataPathRequestParameters = KvReadDataPathRequestQuery & KvReadDataPathRouteParameters & KvReadDataPathRequestHeaders;
interface KvReadDataPathOperation<STATUS extends keyof KvReadDataPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvReadDataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvReadDataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvReadDataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvReadDataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-data-path-request.schema.d.ts
interface KvWriteDataPathRequest {
  /**
   * The contents of the data map will be stored and returned on read.
   * @format map
   */
  data?: Record<string, never>;
  /**
   * Options for writing a KV entry. Set the "cas" value to use a Check-And-Set operation. If not set the write will be allowed. If set to 0 a write will only be allowed if the key doesn’t exist. If the index is non-zero the write will only be allowed if the key’s current version matches the version specified in the cas parameter.
   * @format map
   */
  options?: Record<string, never>;
  /**
   * If provided during a read, the value at the version number will be returned
   */
  version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-data-path.type.d.ts
interface KvWriteDataPathResponseBodies {
  200: void;
}
interface KvWriteDataPathRequestBodies {
  'application/json': KvWriteDataPathRequest;
}
type KvWriteDataPathRequestQuery = {};
type KvWriteDataPathRouteParameters = {};
type KvWriteDataPathRequestHeaders = {};
interface KvWriteDataPathParameterBodies {
  'application/json': KvWriteDataPathRequest & {
    [key: string]: any;
  };
}
type KvWriteDataPathRequestParameters = KvWriteDataPathRequestQuery & KvWriteDataPathRouteParameters & KvWriteDataPathRequestHeaders & KvWriteDataPathRequestBodies['application/json'];
interface KvWriteDataPathOperation<STATUS extends keyof KvWriteDataPathResponseBodies, CONTENT_TYPE extends keyof KvWriteDataPathParameterBodies> extends KeqOperation {
  requestParams: KvWriteDataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteDataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteDataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteDataPathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteDataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-delete-data-path.type.d.ts
interface KvDeleteDataPathResponseBodies {
  204: void;
}
type KvDeleteDataPathRequestQuery = {};
type KvDeleteDataPathRouteParameters = {};
type KvDeleteDataPathRequestHeaders = {};
type KvDeleteDataPathRequestParameters = KvDeleteDataPathRequestQuery & KvDeleteDataPathRouteParameters & KvDeleteDataPathRequestHeaders;
interface KvDeleteDataPathOperation<STATUS extends keyof KvDeleteDataPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvDeleteDataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvDeleteDataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvDeleteDataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvDeleteDataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-delete-path-request.schema.d.ts
interface KvWriteDeletePathRequest {
  /**
   * The versions to be archived. The versioned data will not be deleted, but it will no longer be returned in normal get requests.
   */
  versions?: number[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-delete-path.type.d.ts
interface KvWriteDeletePathResponseBodies {
  200: void;
}
interface KvWriteDeletePathRequestBodies {
  'application/json': KvWriteDeletePathRequest;
}
type KvWriteDeletePathRequestQuery = {};
type KvWriteDeletePathRouteParameters = {};
type KvWriteDeletePathRequestHeaders = {};
interface KvWriteDeletePathParameterBodies {
  'application/json': KvWriteDeletePathRequest & {
    [key: string]: any;
  };
}
type KvWriteDeletePathRequestParameters = KvWriteDeletePathRequestQuery & KvWriteDeletePathRouteParameters & KvWriteDeletePathRequestHeaders & KvWriteDeletePathRequestBodies['application/json'];
interface KvWriteDeletePathOperation<STATUS extends keyof KvWriteDeletePathResponseBodies, CONTENT_TYPE extends keyof KvWriteDeletePathParameterBodies> extends KeqOperation {
  requestParams: KvWriteDeletePathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteDeletePathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteDeletePathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteDeletePathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteDeletePathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-destroy-path-request.schema.d.ts
interface KvWriteDestroyPathRequest {
  /**
   * The versions to destroy. Their data will be permanently deleted.
   */
  versions?: number[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-destroy-path.type.d.ts
interface KvWriteDestroyPathResponseBodies {
  200: void;
}
interface KvWriteDestroyPathRequestBodies {
  'application/json': KvWriteDestroyPathRequest;
}
type KvWriteDestroyPathRequestQuery = {};
type KvWriteDestroyPathRouteParameters = {};
type KvWriteDestroyPathRequestHeaders = {};
interface KvWriteDestroyPathParameterBodies {
  'application/json': KvWriteDestroyPathRequest & {
    [key: string]: any;
  };
}
type KvWriteDestroyPathRequestParameters = KvWriteDestroyPathRequestQuery & KvWriteDestroyPathRouteParameters & KvWriteDestroyPathRequestHeaders & KvWriteDestroyPathRequestBodies['application/json'];
interface KvWriteDestroyPathOperation<STATUS extends keyof KvWriteDestroyPathResponseBodies, CONTENT_TYPE extends keyof KvWriteDestroyPathParameterBodies> extends KeqOperation {
  requestParams: KvWriteDestroyPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteDestroyPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteDestroyPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteDestroyPathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteDestroyPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-list-detailed-metadata-path.type.d.ts
interface KvListDetailedMetadataPathResponseBodies {
  200: void;
}
type KvListDetailedMetadataPathRequestQuery = {
  list: ('true');
};
type KvListDetailedMetadataPathRouteParameters = {};
type KvListDetailedMetadataPathRequestHeaders = {};
type KvListDetailedMetadataPathRequestParameters = KvListDetailedMetadataPathRequestQuery & KvListDetailedMetadataPathRouteParameters & KvListDetailedMetadataPathRequestHeaders;
interface KvListDetailedMetadataPathOperation<STATUS extends keyof KvListDetailedMetadataPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvListDetailedMetadataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvListDetailedMetadataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvListDetailedMetadataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvListDetailedMetadataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-read-metadata-path.type.d.ts
interface KvReadMetadataPathResponseBodies {
  200: void;
}
type KvReadMetadataPathRequestQuery = {
  list?: string;
};
type KvReadMetadataPathRouteParameters = {};
type KvReadMetadataPathRequestHeaders = {};
type KvReadMetadataPathRequestParameters = KvReadMetadataPathRequestQuery & KvReadMetadataPathRouteParameters & KvReadMetadataPathRequestHeaders;
interface KvReadMetadataPathOperation<STATUS extends keyof KvReadMetadataPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvReadMetadataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvReadMetadataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvReadMetadataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvReadMetadataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-metadata-path-request.schema.d.ts
interface KvWriteMetadataPathRequest {
  /**
   * Optional entry to list begin listing after, not required to exist. Only used for listing.
   */
  after?: string;
  /**
   * If true the key will require the cas parameter to be set on all write requests. If false, the backend’s configuration will be used.
   */
  cas_required?: boolean;
  /**
   * User-provided key-value pairs that are used to describe arbitrary and version-agnostic information about a secret.
   * @format map
   */
  custom_metadata?: Record<string, never>;
  /**
   * The length of time before a version is deleted. If not set, the backend's configured delete_version_after is used. Cannot be greater than the backend's delete_version_after. A zero duration clears the current setting. A negative duration will cause an error.
   * @format seconds
   */
  delete_version_after?: number;
  /**
   * Optional number of entries to return; defaults to all entries. Only used for listing.
   */
  limit?: number;
  /**
   * The number of versions to keep. If not set, the backend’s configured max version is used.
   */
  max_versions?: number;
  /**
   * Check-and-set parameter for metadata updates. Must match the current metadata version for the update to succeed. Set to 0 for initial metadata creation.
   */
  metadata_cas?: number;
  /**
   * If true the key will require the cas parameter to be set on all metadata update requests. If false, the backend's configuration will be used.
   */
  metadata_cas_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-metadata-path.type.d.ts
interface KvWriteMetadataPathResponseBodies {
  200: void;
}
interface KvWriteMetadataPathRequestBodies {
  'application/json': KvWriteMetadataPathRequest;
}
type KvWriteMetadataPathRequestQuery = {};
type KvWriteMetadataPathRouteParameters = {};
type KvWriteMetadataPathRequestHeaders = {};
interface KvWriteMetadataPathParameterBodies {
  'application/json': KvWriteMetadataPathRequest & {
    [key: string]: any;
  };
}
type KvWriteMetadataPathRequestParameters = KvWriteMetadataPathRequestQuery & KvWriteMetadataPathRouteParameters & KvWriteMetadataPathRequestHeaders & KvWriteMetadataPathRequestBodies['application/json'];
interface KvWriteMetadataPathOperation<STATUS extends keyof KvWriteMetadataPathResponseBodies, CONTENT_TYPE extends keyof KvWriteMetadataPathParameterBodies> extends KeqOperation {
  requestParams: KvWriteMetadataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteMetadataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteMetadataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteMetadataPathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteMetadataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-delete-metadata-path.type.d.ts
interface KvDeleteMetadataPathResponseBodies {
  204: void;
}
type KvDeleteMetadataPathRequestQuery = {};
type KvDeleteMetadataPathRouteParameters = {};
type KvDeleteMetadataPathRequestHeaders = {};
type KvDeleteMetadataPathRequestParameters = KvDeleteMetadataPathRequestQuery & KvDeleteMetadataPathRouteParameters & KvDeleteMetadataPathRequestHeaders;
interface KvDeleteMetadataPathOperation<STATUS extends keyof KvDeleteMetadataPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvDeleteMetadataPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvDeleteMetadataPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvDeleteMetadataPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvDeleteMetadataPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-read-subkeys-path.type.d.ts
interface KvReadSubkeysPathResponseBodies {
  200: void;
}
type KvReadSubkeysPathRequestQuery = {};
type KvReadSubkeysPathRouteParameters = {};
type KvReadSubkeysPathRequestHeaders = {};
type KvReadSubkeysPathRequestParameters = KvReadSubkeysPathRequestQuery & KvReadSubkeysPathRouteParameters & KvReadSubkeysPathRequestHeaders;
interface KvReadSubkeysPathOperation<STATUS extends keyof KvReadSubkeysPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: KvReadSubkeysPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvReadSubkeysPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvReadSubkeysPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: KvReadSubkeysPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/kv-write-undelete-path-request.schema.d.ts
interface KvWriteUndeletePathRequest {
  /**
   * The versions to unarchive. The versions will be restored and their data will be returned on normal get requests.
   */
  versions?: number[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/kv-write-undelete-path.type.d.ts
interface KvWriteUndeletePathResponseBodies {
  200: void;
}
interface KvWriteUndeletePathRequestBodies {
  'application/json': KvWriteUndeletePathRequest;
}
type KvWriteUndeletePathRequestQuery = {};
type KvWriteUndeletePathRouteParameters = {};
type KvWriteUndeletePathRequestHeaders = {};
interface KvWriteUndeletePathParameterBodies {
  'application/json': KvWriteUndeletePathRequest & {
    [key: string]: any;
  };
}
type KvWriteUndeletePathRequestParameters = KvWriteUndeletePathRequestQuery & KvWriteUndeletePathRouteParameters & KvWriteUndeletePathRequestHeaders & KvWriteUndeletePathRequestBodies['application/json'];
interface KvWriteUndeletePathOperation<STATUS extends keyof KvWriteUndeletePathResponseBodies, CONTENT_TYPE extends keyof KvWriteUndeletePathParameterBodies> extends KeqOperation {
  requestParams: KvWriteUndeletePathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: KvWriteUndeletePathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: KvWriteUndeletePathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: KvWriteUndeletePathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: KvWriteUndeletePathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-list-enabled-devices.type.d.ts
interface AuditingListEnabledDevicesResponseBodies {
  200: void;
}
type AuditingListEnabledDevicesRequestQuery = {};
type AuditingListEnabledDevicesRouteParameters = {};
type AuditingListEnabledDevicesRequestHeaders = {};
type AuditingListEnabledDevicesRequestParameters = AuditingListEnabledDevicesRequestQuery & AuditingListEnabledDevicesRouteParameters & AuditingListEnabledDevicesRequestHeaders;
interface AuditingListEnabledDevicesOperation<STATUS extends keyof AuditingListEnabledDevicesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuditingListEnabledDevicesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingListEnabledDevicesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingListEnabledDevicesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuditingListEnabledDevicesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auditing-calculate-hash-request.schema.d.ts
interface AuditingCalculateHashRequest {
  input?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auditing-calculate-hash-response.schema.d.ts
interface AuditingCalculateHashResponse {
  hash?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-calculate-hash.type.d.ts
interface AuditingCalculateHashResponseBodies {
  200: AuditingCalculateHashResponse;
}
interface AuditingCalculateHashRequestBodies {
  'application/json': AuditingCalculateHashRequest;
}
type AuditingCalculateHashRequestQuery = {};
type AuditingCalculateHashRouteParameters = {};
type AuditingCalculateHashRequestHeaders = {};
interface AuditingCalculateHashParameterBodies {
  'application/json': AuditingCalculateHashRequest & {
    [key: string]: any;
  };
}
type AuditingCalculateHashRequestParameters = AuditingCalculateHashRequestQuery & AuditingCalculateHashRouteParameters & AuditingCalculateHashRequestHeaders & AuditingCalculateHashRequestBodies['application/json'];
interface AuditingCalculateHashOperation<STATUS extends keyof AuditingCalculateHashResponseBodies, CONTENT_TYPE extends keyof AuditingCalculateHashParameterBodies> extends KeqOperation {
  requestParams: AuditingCalculateHashRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingCalculateHashRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingCalculateHashRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AuditingCalculateHashParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AuditingCalculateHashResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auditing-enable-device-request.schema.d.ts
interface AuditingEnableDeviceRequest {
  /**
   * User-friendly description for this audit backend.
   */
  description?: string;
  /**
   * Mark the mount as a local mount, which is not replicated and is unaffected by replication.
   */
  local?: boolean;
  /**
   * Configuration options for the audit backend.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * The type of the backend. Example: "mysql"
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-enable-device.type.d.ts
interface AuditingEnableDeviceResponseBodies {
  204: void;
}
interface AuditingEnableDeviceRequestBodies {
  'application/json': AuditingEnableDeviceRequest;
}
type AuditingEnableDeviceRequestQuery = {};
type AuditingEnableDeviceRouteParameters = {};
type AuditingEnableDeviceRequestHeaders = {};
interface AuditingEnableDeviceParameterBodies {
  'application/json': AuditingEnableDeviceRequest & {
    [key: string]: any;
  };
}
type AuditingEnableDeviceRequestParameters = AuditingEnableDeviceRequestQuery & AuditingEnableDeviceRouteParameters & AuditingEnableDeviceRequestHeaders & AuditingEnableDeviceRequestBodies['application/json'];
interface AuditingEnableDeviceOperation<STATUS extends keyof AuditingEnableDeviceResponseBodies, CONTENT_TYPE extends keyof AuditingEnableDeviceParameterBodies> extends KeqOperation {
  requestParams: AuditingEnableDeviceRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingEnableDeviceRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingEnableDeviceRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AuditingEnableDeviceParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AuditingEnableDeviceResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-disable-device.type.d.ts
interface AuditingDisableDeviceResponseBodies {
  204: void;
}
type AuditingDisableDeviceRequestQuery = {};
type AuditingDisableDeviceRouteParameters = {};
type AuditingDisableDeviceRequestHeaders = {};
type AuditingDisableDeviceRequestParameters = AuditingDisableDeviceRequestQuery & AuditingDisableDeviceRouteParameters & AuditingDisableDeviceRequestHeaders;
interface AuditingDisableDeviceOperation<STATUS extends keyof AuditingDisableDeviceResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuditingDisableDeviceRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingDisableDeviceRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingDisableDeviceRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuditingDisableDeviceResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-list-enabled-methods.type.d.ts
interface AuthListEnabledMethodsResponseBodies {
  200: void;
}
type AuthListEnabledMethodsRequestQuery = {};
type AuthListEnabledMethodsRouteParameters = {};
type AuthListEnabledMethodsRequestHeaders = {};
type AuthListEnabledMethodsRequestParameters = AuthListEnabledMethodsRequestQuery & AuthListEnabledMethodsRouteParameters & AuthListEnabledMethodsRequestHeaders;
interface AuthListEnabledMethodsOperation<STATUS extends keyof AuthListEnabledMethodsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuthListEnabledMethodsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthListEnabledMethodsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthListEnabledMethodsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuthListEnabledMethodsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auth-read-configuration-response.schema.d.ts
interface AuthReadConfigurationResponse {
  accessor?: string;
  /**
   * @format map
   */
  config?: Record<string, never>;
  deprecation_status?: string;
  description?: string;
  external_entropy_access?: boolean;
  local?: boolean;
  /**
   * @format map
   */
  options?: Record<string, never>;
  plugin_version?: string;
  running_plugin_version?: string;
  running_sha256?: string;
  seal_wrap?: boolean;
  type?: string;
  uuid?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-read-configuration.type.d.ts
interface AuthReadConfigurationResponseBodies {
  200: AuthReadConfigurationResponse;
}
type AuthReadConfigurationRequestQuery = {};
type AuthReadConfigurationRouteParameters = {};
type AuthReadConfigurationRequestHeaders = {};
type AuthReadConfigurationRequestParameters = AuthReadConfigurationRequestQuery & AuthReadConfigurationRouteParameters & AuthReadConfigurationRequestHeaders;
interface AuthReadConfigurationOperation<STATUS extends keyof AuthReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuthReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuthReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auth-enable-method-request.schema.d.ts
interface AuthEnableMethodRequest {
  /**
   * Configuration for this mount, such as plugin_name.
   * @format map
   */
  config?: Record<string, never>;
  /**
   * User-friendly description for this credential backend.
   */
  description?: string;
  /**
   * Whether to give the mount access to OpenBao's external entropy.
   */
  external_entropy_access?: boolean;
  /**
   * Mark the mount as a local mount, which is not replicated and is unaffected by replication.
   */
  local?: boolean;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * Name of the auth plugin to use based from the name in the plugin catalog.
   */
  plugin_name?: string;
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  /**
   * Whether to turn on seal wrapping for the mount.
   */
  seal_wrap?: boolean;
  /**
   * The type of the backend. Example: "userpass"
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-enable-method.type.d.ts
interface AuthEnableMethodResponseBodies {
  204: void;
}
interface AuthEnableMethodRequestBodies {
  'application/json': AuthEnableMethodRequest;
}
type AuthEnableMethodRequestQuery = {};
type AuthEnableMethodRouteParameters = {};
type AuthEnableMethodRequestHeaders = {};
interface AuthEnableMethodParameterBodies {
  'application/json': AuthEnableMethodRequest & {
    [key: string]: any;
  };
}
type AuthEnableMethodRequestParameters = AuthEnableMethodRequestQuery & AuthEnableMethodRouteParameters & AuthEnableMethodRequestHeaders & AuthEnableMethodRequestBodies['application/json'];
interface AuthEnableMethodOperation<STATUS extends keyof AuthEnableMethodResponseBodies, CONTENT_TYPE extends keyof AuthEnableMethodParameterBodies> extends KeqOperation {
  requestParams: AuthEnableMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthEnableMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthEnableMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AuthEnableMethodParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AuthEnableMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-disable-method.type.d.ts
interface AuthDisableMethodResponseBodies {
  204: void;
}
type AuthDisableMethodRequestQuery = {};
type AuthDisableMethodRouteParameters = {};
type AuthDisableMethodRequestHeaders = {};
type AuthDisableMethodRequestParameters = AuthDisableMethodRequestQuery & AuthDisableMethodRouteParameters & AuthDisableMethodRequestHeaders;
interface AuthDisableMethodOperation<STATUS extends keyof AuthDisableMethodResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuthDisableMethodRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthDisableMethodRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthDisableMethodRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuthDisableMethodResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auth-read-tuning-information-response.schema.d.ts
interface AuthReadTuningInformationResponse {
  allowed_managed_keys?: string[];
  allowed_response_headers?: string[];
  audit_non_hmac_request_keys?: string[];
  audit_non_hmac_response_keys?: string[];
  default_lease_ttl?: number;
  description?: string;
  external_entropy_access?: boolean;
  force_no_cache?: boolean;
  listing_visibility?: string;
  max_lease_ttl?: number;
  /**
   * @format map
   */
  options?: Record<string, never>;
  passthrough_request_headers?: string[];
  plugin_version?: string;
  token_type?: string;
  /**
   * @format int64
   */
  user_lockout_counter_reset_duration?: number;
  user_lockout_disable?: boolean;
  /**
   * @format int64
   */
  user_lockout_duration?: number;
  /**
   * @format int64
   */
  user_lockout_threshold?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-read-tuning-information.type.d.ts
interface AuthReadTuningInformationResponseBodies {
  200: AuthReadTuningInformationResponse;
}
type AuthReadTuningInformationRequestQuery = {};
type AuthReadTuningInformationRouteParameters = {};
type AuthReadTuningInformationRequestHeaders = {};
type AuthReadTuningInformationRequestParameters = AuthReadTuningInformationRequestQuery & AuthReadTuningInformationRouteParameters & AuthReadTuningInformationRequestHeaders;
interface AuthReadTuningInformationOperation<STATUS extends keyof AuthReadTuningInformationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuthReadTuningInformationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthReadTuningInformationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthReadTuningInformationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuthReadTuningInformationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auth-tune-configuration-parameters-request.schema.d.ts
interface AuthTuneConfigurationParametersRequest {
  /**
   * A list of headers to whitelist and allow a plugin to set on responses.
   */
  allowed_response_headers?: string[];
  /**
   * The list of keys in the request data object that will not be HMAC'ed by audit devices.
   */
  audit_non_hmac_request_keys?: string[];
  /**
   * The list of keys in the response data object that will not be HMAC'ed by audit devices.
   */
  audit_non_hmac_response_keys?: string[];
  /**
   * The default lease TTL for this mount.
   */
  default_lease_ttl?: string;
  /**
   * User-friendly description for this credential backend.
   */
  description?: string;
  /**
   * Determines the visibility of the mount in the UI-specific listing endpoint. Accepted value are 'unauth' and 'hidden', with the empty default ('') behaving like 'hidden'.
   */
  listing_visibility?: string;
  /**
   * The max lease TTL for this mount.
   */
  max_lease_ttl?: string;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * A list of headers to whitelist and pass from the request to the plugin.
   */
  passthrough_request_headers?: string[];
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  /**
   * The type of token to issue (service or batch).
   */
  token_type?: string;
  /**
   * The user lockout configuration to pass into the backend. Should be a json object with string keys and values.
   * @format map
   */
  user_lockout_config?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auth-tune-configuration-parameters.type.d.ts
interface AuthTuneConfigurationParametersResponseBodies {
  204: void;
}
interface AuthTuneConfigurationParametersRequestBodies {
  'application/json': AuthTuneConfigurationParametersRequest;
}
type AuthTuneConfigurationParametersRequestQuery = {};
type AuthTuneConfigurationParametersRouteParameters = {};
type AuthTuneConfigurationParametersRequestHeaders = {};
interface AuthTuneConfigurationParametersParameterBodies {
  'application/json': AuthTuneConfigurationParametersRequest & {
    [key: string]: any;
  };
}
type AuthTuneConfigurationParametersRequestParameters = AuthTuneConfigurationParametersRequestQuery & AuthTuneConfigurationParametersRouteParameters & AuthTuneConfigurationParametersRequestHeaders & AuthTuneConfigurationParametersRequestBodies['application/json'];
interface AuthTuneConfigurationParametersOperation<STATUS extends keyof AuthTuneConfigurationParametersResponseBodies, CONTENT_TYPE extends keyof AuthTuneConfigurationParametersParameterBodies> extends KeqOperation {
  requestParams: AuthTuneConfigurationParametersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuthTuneConfigurationParametersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuthTuneConfigurationParametersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AuthTuneConfigurationParametersParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AuthTuneConfigurationParametersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/query-token-capabilities-request.schema.d.ts
interface QueryTokenCapabilitiesRequest {
  /**
   * Use 'paths' instead.
   * @deprecated
   */
  path?: string[];
  /**
   * Paths on which capabilities are being queried.
   */
  paths?: string[];
  /**
   * Token for which capabilities are being queried.
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/query-token-capabilities.type.d.ts
interface QueryTokenCapabilitiesResponseBodies {
  200: void;
}
interface QueryTokenCapabilitiesRequestBodies {
  'application/json': QueryTokenCapabilitiesRequest;
}
type QueryTokenCapabilitiesRequestQuery = {};
type QueryTokenCapabilitiesRouteParameters = {};
type QueryTokenCapabilitiesRequestHeaders = {};
interface QueryTokenCapabilitiesParameterBodies {
  'application/json': QueryTokenCapabilitiesRequest & {
    [key: string]: any;
  };
}
type QueryTokenCapabilitiesRequestParameters = QueryTokenCapabilitiesRequestQuery & QueryTokenCapabilitiesRouteParameters & QueryTokenCapabilitiesRequestHeaders & QueryTokenCapabilitiesRequestBodies['application/json'];
interface QueryTokenCapabilitiesOperation<STATUS extends keyof QueryTokenCapabilitiesResponseBodies, CONTENT_TYPE extends keyof QueryTokenCapabilitiesParameterBodies> extends KeqOperation {
  requestParams: QueryTokenCapabilitiesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: QueryTokenCapabilitiesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: QueryTokenCapabilitiesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: QueryTokenCapabilitiesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: QueryTokenCapabilitiesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/query-token-accessor-capabilities-request.schema.d.ts
interface QueryTokenAccessorCapabilitiesRequest {
  /**
   * Accessor of the token for which capabilities are being queried.
   */
  accessor?: string;
  /**
   * Use 'paths' instead.
   * @deprecated
   */
  path?: string[];
  /**
   * Paths on which capabilities are being queried.
   */
  paths?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/query-token-accessor-capabilities.type.d.ts
interface QueryTokenAccessorCapabilitiesResponseBodies {
  200: void;
}
interface QueryTokenAccessorCapabilitiesRequestBodies {
  'application/json': QueryTokenAccessorCapabilitiesRequest;
}
type QueryTokenAccessorCapabilitiesRequestQuery = {};
type QueryTokenAccessorCapabilitiesRouteParameters = {};
type QueryTokenAccessorCapabilitiesRequestHeaders = {};
interface QueryTokenAccessorCapabilitiesParameterBodies {
  'application/json': QueryTokenAccessorCapabilitiesRequest & {
    [key: string]: any;
  };
}
type QueryTokenAccessorCapabilitiesRequestParameters = QueryTokenAccessorCapabilitiesRequestQuery & QueryTokenAccessorCapabilitiesRouteParameters & QueryTokenAccessorCapabilitiesRequestHeaders & QueryTokenAccessorCapabilitiesRequestBodies['application/json'];
interface QueryTokenAccessorCapabilitiesOperation<STATUS extends keyof QueryTokenAccessorCapabilitiesResponseBodies, CONTENT_TYPE extends keyof QueryTokenAccessorCapabilitiesParameterBodies> extends KeqOperation {
  requestParams: QueryTokenAccessorCapabilitiesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: QueryTokenAccessorCapabilitiesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: QueryTokenAccessorCapabilitiesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: QueryTokenAccessorCapabilitiesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: QueryTokenAccessorCapabilitiesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/query-token-self-capabilities-request.schema.d.ts
interface QueryTokenSelfCapabilitiesRequest {
  /**
   * Use 'paths' instead.
   * @deprecated
   */
  path?: string[];
  /**
   * Paths on which capabilities are being queried.
   */
  paths?: string[];
  /**
   * Token for which capabilities are being queried.
   */
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/query-token-self-capabilities.type.d.ts
interface QueryTokenSelfCapabilitiesResponseBodies {
  200: void;
}
interface QueryTokenSelfCapabilitiesRequestBodies {
  'application/json': QueryTokenSelfCapabilitiesRequest;
}
type QueryTokenSelfCapabilitiesRequestQuery = {};
type QueryTokenSelfCapabilitiesRouteParameters = {};
type QueryTokenSelfCapabilitiesRequestHeaders = {};
interface QueryTokenSelfCapabilitiesParameterBodies {
  'application/json': QueryTokenSelfCapabilitiesRequest & {
    [key: string]: any;
  };
}
type QueryTokenSelfCapabilitiesRequestParameters = QueryTokenSelfCapabilitiesRequestQuery & QueryTokenSelfCapabilitiesRouteParameters & QueryTokenSelfCapabilitiesRequestHeaders & QueryTokenSelfCapabilitiesRequestBodies['application/json'];
interface QueryTokenSelfCapabilitiesOperation<STATUS extends keyof QueryTokenSelfCapabilitiesResponseBodies, CONTENT_TYPE extends keyof QueryTokenSelfCapabilitiesParameterBodies> extends KeqOperation {
  requestParams: QueryTokenSelfCapabilitiesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: QueryTokenSelfCapabilitiesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: QueryTokenSelfCapabilitiesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: QueryTokenSelfCapabilitiesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: QueryTokenSelfCapabilitiesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auditing-list-request-headers-response.schema.d.ts
interface AuditingListRequestHeadersResponse {
  /**
   * @format map
   */
  headers?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-list-request-headers.type.d.ts
interface AuditingListRequestHeadersResponseBodies {
  200: AuditingListRequestHeadersResponse;
}
type AuditingListRequestHeadersRequestQuery = {};
type AuditingListRequestHeadersRouteParameters = {};
type AuditingListRequestHeadersRequestHeaders = {};
type AuditingListRequestHeadersRequestParameters = AuditingListRequestHeadersRequestQuery & AuditingListRequestHeadersRouteParameters & AuditingListRequestHeadersRequestHeaders;
interface AuditingListRequestHeadersOperation<STATUS extends keyof AuditingListRequestHeadersResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuditingListRequestHeadersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingListRequestHeadersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingListRequestHeadersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuditingListRequestHeadersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-read-request-header-information.type.d.ts
interface AuditingReadRequestHeaderInformationResponseBodies {
  200: void;
}
type AuditingReadRequestHeaderInformationRequestQuery = {};
type AuditingReadRequestHeaderInformationRouteParameters = {};
type AuditingReadRequestHeaderInformationRequestHeaders = {};
type AuditingReadRequestHeaderInformationRequestParameters = AuditingReadRequestHeaderInformationRequestQuery & AuditingReadRequestHeaderInformationRouteParameters & AuditingReadRequestHeaderInformationRequestHeaders;
interface AuditingReadRequestHeaderInformationOperation<STATUS extends keyof AuditingReadRequestHeaderInformationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuditingReadRequestHeaderInformationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingReadRequestHeaderInformationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingReadRequestHeaderInformationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuditingReadRequestHeaderInformationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/auditing-enable-request-header-request.schema.d.ts
interface AuditingEnableRequestHeaderRequest {
  hmac?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-enable-request-header.type.d.ts
interface AuditingEnableRequestHeaderResponseBodies {
  204: void;
}
interface AuditingEnableRequestHeaderRequestBodies {
  'application/json': AuditingEnableRequestHeaderRequest;
}
type AuditingEnableRequestHeaderRequestQuery = {};
type AuditingEnableRequestHeaderRouteParameters = {};
type AuditingEnableRequestHeaderRequestHeaders = {};
interface AuditingEnableRequestHeaderParameterBodies {
  'application/json': AuditingEnableRequestHeaderRequest & {
    [key: string]: any;
  };
}
type AuditingEnableRequestHeaderRequestParameters = AuditingEnableRequestHeaderRequestQuery & AuditingEnableRequestHeaderRouteParameters & AuditingEnableRequestHeaderRequestHeaders & AuditingEnableRequestHeaderRequestBodies['application/json'];
interface AuditingEnableRequestHeaderOperation<STATUS extends keyof AuditingEnableRequestHeaderResponseBodies, CONTENT_TYPE extends keyof AuditingEnableRequestHeaderParameterBodies> extends KeqOperation {
  requestParams: AuditingEnableRequestHeaderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingEnableRequestHeaderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingEnableRequestHeaderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: AuditingEnableRequestHeaderParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: AuditingEnableRequestHeaderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/auditing-disable-request-header.type.d.ts
interface AuditingDisableRequestHeaderResponseBodies {
  204: void;
}
type AuditingDisableRequestHeaderRequestQuery = {};
type AuditingDisableRequestHeaderRouteParameters = {};
type AuditingDisableRequestHeaderRequestHeaders = {};
type AuditingDisableRequestHeaderRequestParameters = AuditingDisableRequestHeaderRequestQuery & AuditingDisableRequestHeaderRouteParameters & AuditingDisableRequestHeaderRequestHeaders;
interface AuditingDisableRequestHeaderOperation<STATUS extends keyof AuditingDisableRequestHeaderResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: AuditingDisableRequestHeaderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: AuditingDisableRequestHeaderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: AuditingDisableRequestHeaderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: AuditingDisableRequestHeaderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/cors-read-configuration-response.schema.d.ts
interface CorsReadConfigurationResponse {
  allowed_headers?: string[];
  allowed_origins?: string[];
  enabled?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cors-read-configuration.type.d.ts
interface CorsReadConfigurationResponseBodies {
  200: CorsReadConfigurationResponse;
}
type CorsReadConfigurationRequestQuery = {};
type CorsReadConfigurationRouteParameters = {};
type CorsReadConfigurationRequestHeaders = {};
type CorsReadConfigurationRequestParameters = CorsReadConfigurationRequestQuery & CorsReadConfigurationRouteParameters & CorsReadConfigurationRequestHeaders;
interface CorsReadConfigurationOperation<STATUS extends keyof CorsReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CorsReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CorsReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CorsReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CorsReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/cors-configure-request.schema.d.ts
interface CorsConfigureRequest {
  /**
   * A comma-separated string or array of strings indicating headers that are allowed on cross-origin requests.
   */
  allowed_headers?: string[];
  /**
   * A comma-separated string or array of strings indicating origins that may make cross-origin requests.
   */
  allowed_origins?: string[];
  /**
   * Enables or disables CORS headers on requests.
   */
  enable?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cors-configure.type.d.ts
interface CorsConfigureResponseBodies {
  204: void;
}
interface CorsConfigureRequestBodies {
  'application/json': CorsConfigureRequest;
}
type CorsConfigureRequestQuery = {};
type CorsConfigureRouteParameters = {};
type CorsConfigureRequestHeaders = {};
interface CorsConfigureParameterBodies {
  'application/json': CorsConfigureRequest & {
    [key: string]: any;
  };
}
type CorsConfigureRequestParameters = CorsConfigureRequestQuery & CorsConfigureRouteParameters & CorsConfigureRequestHeaders & CorsConfigureRequestBodies['application/json'];
interface CorsConfigureOperation<STATUS extends keyof CorsConfigureResponseBodies, CONTENT_TYPE extends keyof CorsConfigureParameterBodies> extends KeqOperation {
  requestParams: CorsConfigureRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CorsConfigureRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CorsConfigureRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: CorsConfigureParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: CorsConfigureResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/cors-delete-configuration.type.d.ts
interface CorsDeleteConfigurationResponseBodies {
  204: void;
}
type CorsDeleteConfigurationRequestQuery = {};
type CorsDeleteConfigurationRouteParameters = {};
type CorsDeleteConfigurationRequestHeaders = {};
type CorsDeleteConfigurationRequestParameters = CorsDeleteConfigurationRequestQuery & CorsDeleteConfigurationRouteParameters & CorsDeleteConfigurationRequestHeaders;
interface CorsDeleteConfigurationOperation<STATUS extends keyof CorsDeleteConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CorsDeleteConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CorsDeleteConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CorsDeleteConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CorsDeleteConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/reload-subsystem.type.d.ts
interface ReloadSubsystemResponseBodies {
  204: void;
}
type ReloadSubsystemRequestQuery = {};
type ReloadSubsystemRouteParameters = {};
type ReloadSubsystemRequestHeaders = {};
type ReloadSubsystemRequestParameters = ReloadSubsystemRequestQuery & ReloadSubsystemRouteParameters & ReloadSubsystemRequestHeaders;
interface ReloadSubsystemOperation<STATUS extends keyof ReloadSubsystemResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: ReloadSubsystemRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: ReloadSubsystemRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: ReloadSubsystemRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: ReloadSubsystemResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/read-sanitized-configuration-state.type.d.ts
interface ReadSanitizedConfigurationStateResponseBodies {
  200: void;
}
type ReadSanitizedConfigurationStateRequestQuery = {};
type ReadSanitizedConfigurationStateRouteParameters = {};
type ReadSanitizedConfigurationStateRequestHeaders = {};
type ReadSanitizedConfigurationStateRequestParameters = ReadSanitizedConfigurationStateRequestQuery & ReadSanitizedConfigurationStateRouteParameters & ReadSanitizedConfigurationStateRequestHeaders;
interface ReadSanitizedConfigurationStateOperation<STATUS extends keyof ReadSanitizedConfigurationStateResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: ReadSanitizedConfigurationStateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: ReadSanitizedConfigurationStateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: ReadSanitizedConfigurationStateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: ReadSanitizedConfigurationStateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/ui-headers-list-response.schema.d.ts
interface UiHeadersListResponse {
  /**
   * Lists of configured UI headers. Omitted if list is empty
   */
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/ui-headers-list.type.d.ts
interface UiHeadersListResponseBodies {
  200: UiHeadersListResponse;
}
type UiHeadersListRequestQuery = {
  list: ('true');
};
type UiHeadersListRouteParameters = {};
type UiHeadersListRequestHeaders = {};
type UiHeadersListRequestParameters = UiHeadersListRequestQuery & UiHeadersListRouteParameters & UiHeadersListRequestHeaders;
interface UiHeadersListOperation<STATUS extends keyof UiHeadersListResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UiHeadersListRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UiHeadersListRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UiHeadersListRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UiHeadersListResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/ui-headers-read-configuration-response.schema.d.ts
interface UiHeadersReadConfigurationResponse {
  /**
   * returns the first header value when `multivalue` request parameter is false
   */
  value?: string;
  /**
   * returns all header values when `multivalue` request parameter is true
   */
  values?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/ui-headers-read-configuration.type.d.ts
interface UiHeadersReadConfigurationResponseBodies {
  200: UiHeadersReadConfigurationResponse;
}
type UiHeadersReadConfigurationRequestQuery = {};
type UiHeadersReadConfigurationRouteParameters = {};
type UiHeadersReadConfigurationRequestHeaders = {};
type UiHeadersReadConfigurationRequestParameters = UiHeadersReadConfigurationRequestQuery & UiHeadersReadConfigurationRouteParameters & UiHeadersReadConfigurationRequestHeaders;
interface UiHeadersReadConfigurationOperation<STATUS extends keyof UiHeadersReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UiHeadersReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UiHeadersReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UiHeadersReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UiHeadersReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/ui-headers-configure-request.schema.d.ts
interface UiHeadersConfigureRequest {
  /**
   * Returns multiple values if true
   */
  multivalue?: boolean;
  /**
   * The values to set the header.
   */
  values?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/ui-headers-configure.type.d.ts
interface UiHeadersConfigureResponseBodies {
  200: void;
}
interface UiHeadersConfigureRequestBodies {
  'application/json': UiHeadersConfigureRequest;
}
type UiHeadersConfigureRequestQuery = {};
type UiHeadersConfigureRouteParameters = {};
type UiHeadersConfigureRequestHeaders = {};
interface UiHeadersConfigureParameterBodies {
  'application/json': UiHeadersConfigureRequest & {
    [key: string]: any;
  };
}
type UiHeadersConfigureRequestParameters = UiHeadersConfigureRequestQuery & UiHeadersConfigureRouteParameters & UiHeadersConfigureRequestHeaders & UiHeadersConfigureRequestBodies['application/json'];
interface UiHeadersConfigureOperation<STATUS extends keyof UiHeadersConfigureResponseBodies, CONTENT_TYPE extends keyof UiHeadersConfigureParameterBodies> extends KeqOperation {
  requestParams: UiHeadersConfigureRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UiHeadersConfigureRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UiHeadersConfigureRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UiHeadersConfigureParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UiHeadersConfigureResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/ui-headers-delete-configuration.type.d.ts
interface UiHeadersDeleteConfigurationResponseBodies {
  204: void;
}
type UiHeadersDeleteConfigurationRequestQuery = {};
type UiHeadersDeleteConfigurationRouteParameters = {};
type UiHeadersDeleteConfigurationRequestHeaders = {};
type UiHeadersDeleteConfigurationRequestParameters = UiHeadersDeleteConfigurationRequestQuery & UiHeadersDeleteConfigurationRouteParameters & UiHeadersDeleteConfigurationRequestHeaders;
interface UiHeadersDeleteConfigurationOperation<STATUS extends keyof UiHeadersDeleteConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: UiHeadersDeleteConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UiHeadersDeleteConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UiHeadersDeleteConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: UiHeadersDeleteConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/decode-request.schema.d.ts
interface DecodeRequest {
  /**
   * Specifies the encoded token (result from generate-root).
   */
  encoded_token?: string;
  /**
   * Specifies the otp code for decode.
   */
  otp?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/decode.type.d.ts
interface DecodeResponseBodies {
  200: void;
}
interface DecodeRequestBodies {
  'application/json': DecodeRequest;
}
type DecodeRequestQuery = {};
type DecodeRouteParameters = {};
type DecodeRequestHeaders = {};
interface DecodeParameterBodies {
  'application/json': DecodeRequest & {
    [key: string]: any;
  };
}
type DecodeRequestParameters = DecodeRequestQuery & DecodeRouteParameters & DecodeRequestHeaders & DecodeRequestBodies['application/json'];
interface DecodeOperation<STATUS extends keyof DecodeResponseBodies, CONTENT_TYPE extends keyof DecodeParameterBodies> extends KeqOperation {
  requestParams: DecodeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: DecodeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: DecodeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: DecodeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: DecodeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-read-progress2-response.schema.d.ts
interface RootTokenGenerationReadProgress2Response {
  complete?: boolean;
  encoded_root_token?: string;
  encoded_token?: string;
  nonce?: string;
  otp?: string;
  otp_length?: number;
  pgp_fingerprint?: string;
  progress?: number;
  required?: number;
  started?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-token-generation-read-progress2.type.d.ts
interface RootTokenGenerationReadProgress2ResponseBodies {
  200: RootTokenGenerationReadProgress2Response;
}
type RootTokenGenerationReadProgress2RequestQuery = {};
type RootTokenGenerationReadProgress2RouteParameters = {};
type RootTokenGenerationReadProgress2RequestHeaders = {};
type RootTokenGenerationReadProgress2RequestParameters = RootTokenGenerationReadProgress2RequestQuery & RootTokenGenerationReadProgress2RouteParameters & RootTokenGenerationReadProgress2RequestHeaders;
interface RootTokenGenerationReadProgress2Operation<STATUS extends keyof RootTokenGenerationReadProgress2ResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RootTokenGenerationReadProgress2RouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootTokenGenerationReadProgress2RequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootTokenGenerationReadProgress2RequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RootTokenGenerationReadProgress2ResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-read-progress-response.schema.d.ts
interface RootTokenGenerationReadProgressResponse {
  complete?: boolean;
  encoded_root_token?: string;
  encoded_token?: string;
  nonce?: string;
  otp?: string;
  otp_length?: number;
  pgp_fingerprint?: string;
  progress?: number;
  required?: number;
  started?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-token-generation-read-progress.type.d.ts
interface RootTokenGenerationReadProgressResponseBodies {
  200: RootTokenGenerationReadProgressResponse;
}
type RootTokenGenerationReadProgressRequestQuery = {};
type RootTokenGenerationReadProgressRouteParameters = {};
type RootTokenGenerationReadProgressRequestHeaders = {};
type RootTokenGenerationReadProgressRequestParameters = RootTokenGenerationReadProgressRequestQuery & RootTokenGenerationReadProgressRouteParameters & RootTokenGenerationReadProgressRequestHeaders;
interface RootTokenGenerationReadProgressOperation<STATUS extends keyof RootTokenGenerationReadProgressResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RootTokenGenerationReadProgressRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootTokenGenerationReadProgressRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootTokenGenerationReadProgressRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RootTokenGenerationReadProgressResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-initialize-request.schema.d.ts
interface RootTokenGenerationInitializeRequest {
  /**
   * Specifies a base64-encoded PGP public key.
   */
  pgp_key?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-initialize-response.schema.d.ts
interface RootTokenGenerationInitializeResponse {
  complete?: boolean;
  encoded_root_token?: string;
  encoded_token?: string;
  nonce?: string;
  otp?: string;
  otp_length?: number;
  pgp_fingerprint?: string;
  progress?: number;
  required?: number;
  started?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-token-generation-initialize.type.d.ts
interface RootTokenGenerationInitializeResponseBodies {
  200: RootTokenGenerationInitializeResponse;
}
interface RootTokenGenerationInitializeRequestBodies {
  'application/json': RootTokenGenerationInitializeRequest;
}
type RootTokenGenerationInitializeRequestQuery = {};
type RootTokenGenerationInitializeRouteParameters = {};
type RootTokenGenerationInitializeRequestHeaders = {};
interface RootTokenGenerationInitializeParameterBodies {
  'application/json': RootTokenGenerationInitializeRequest & {
    [key: string]: any;
  };
}
type RootTokenGenerationInitializeRequestParameters = RootTokenGenerationInitializeRequestQuery & RootTokenGenerationInitializeRouteParameters & RootTokenGenerationInitializeRequestHeaders & RootTokenGenerationInitializeRequestBodies['application/json'];
interface RootTokenGenerationInitializeOperation<STATUS extends keyof RootTokenGenerationInitializeResponseBodies, CONTENT_TYPE extends keyof RootTokenGenerationInitializeParameterBodies> extends KeqOperation {
  requestParams: RootTokenGenerationInitializeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootTokenGenerationInitializeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootTokenGenerationInitializeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RootTokenGenerationInitializeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RootTokenGenerationInitializeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-token-generation-cancel.type.d.ts
interface RootTokenGenerationCancelResponseBodies {
  204: void;
}
type RootTokenGenerationCancelRequestQuery = {};
type RootTokenGenerationCancelRouteParameters = {};
type RootTokenGenerationCancelRequestHeaders = {};
type RootTokenGenerationCancelRequestParameters = RootTokenGenerationCancelRequestQuery & RootTokenGenerationCancelRouteParameters & RootTokenGenerationCancelRequestHeaders;
interface RootTokenGenerationCancelOperation<STATUS extends keyof RootTokenGenerationCancelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RootTokenGenerationCancelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootTokenGenerationCancelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootTokenGenerationCancelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RootTokenGenerationCancelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-update-request.schema.d.ts
interface RootTokenGenerationUpdateRequest {
  /**
   * Specifies a single unseal key share.
   */
  key?: string;
  /**
   * Specifies the nonce of the attempt.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/root-token-generation-update-response.schema.d.ts
interface RootTokenGenerationUpdateResponse {
  complete?: boolean;
  encoded_root_token?: string;
  encoded_token?: string;
  nonce?: string;
  otp?: string;
  otp_length?: number;
  pgp_fingerprint?: string;
  progress?: number;
  required?: number;
  started?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-token-generation-update.type.d.ts
interface RootTokenGenerationUpdateResponseBodies {
  200: RootTokenGenerationUpdateResponse;
}
interface RootTokenGenerationUpdateRequestBodies {
  'application/json': RootTokenGenerationUpdateRequest;
}
type RootTokenGenerationUpdateRequestQuery = {};
type RootTokenGenerationUpdateRouteParameters = {};
type RootTokenGenerationUpdateRequestHeaders = {};
interface RootTokenGenerationUpdateParameterBodies {
  'application/json': RootTokenGenerationUpdateRequest & {
    [key: string]: any;
  };
}
type RootTokenGenerationUpdateRequestParameters = RootTokenGenerationUpdateRequestQuery & RootTokenGenerationUpdateRouteParameters & RootTokenGenerationUpdateRequestHeaders & RootTokenGenerationUpdateRequestBodies['application/json'];
interface RootTokenGenerationUpdateOperation<STATUS extends keyof RootTokenGenerationUpdateResponseBodies, CONTENT_TYPE extends keyof RootTokenGenerationUpdateParameterBodies> extends KeqOperation {
  requestParams: RootTokenGenerationUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootTokenGenerationUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootTokenGenerationUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RootTokenGenerationUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RootTokenGenerationUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/ha-status-response.schema.d.ts
interface HaStatusResponse {
  nodes?: Record<string, never>[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/ha-status.type.d.ts
interface HaStatusResponseBodies {
  200: HaStatusResponse;
}
type HaStatusRequestQuery = {};
type HaStatusRouteParameters = {};
type HaStatusRequestHeaders = {};
type HaStatusRequestParameters = HaStatusRequestQuery & HaStatusRouteParameters & HaStatusRequestHeaders;
interface HaStatusOperation<STATUS extends keyof HaStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: HaStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: HaStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: HaStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: HaStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/read-health-status.type.d.ts
interface ReadHealthStatusResponseBodies {
  200: void;
  429: void;
  472: void;
  501: void;
  503: void;
}
type ReadHealthStatusRequestQuery = {};
type ReadHealthStatusRouteParameters = {};
type ReadHealthStatusRequestHeaders = {};
type ReadHealthStatusRequestParameters = ReadHealthStatusRequestQuery & ReadHealthStatusRouteParameters & ReadHealthStatusRequestHeaders;
interface ReadHealthStatusOperation<STATUS extends keyof ReadHealthStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: ReadHealthStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: ReadHealthStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: ReadHealthStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: ReadHealthStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/collect-host-information-response.schema.d.ts
interface CollectHostInformationResponse {
  cpu?: Record<string, never>[];
  cpu_times?: Record<string, never>[];
  disk?: Record<string, never>[];
  /**
   * @format map
   */
  host?: Record<string, never>;
  /**
   * @format map
   */
  memory?: Record<string, never>;
  /**
   * @format date-time
   */
  timestamp?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/collect-host-information.type.d.ts
interface CollectHostInformationResponseBodies {
  200: CollectHostInformationResponse;
}
type CollectHostInformationRequestQuery = {};
type CollectHostInformationRouteParameters = {};
type CollectHostInformationRequestHeaders = {};
type CollectHostInformationRequestParameters = CollectHostInformationRequestQuery & CollectHostInformationRouteParameters & CollectHostInformationRequestHeaders;
interface CollectHostInformationOperation<STATUS extends keyof CollectHostInformationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CollectHostInformationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CollectHostInformationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CollectHostInformationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CollectHostInformationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/collect-in-flight-request-information.type.d.ts
interface CollectInFlightRequestInformationResponseBodies {
  200: void;
}
type CollectInFlightRequestInformationRequestQuery = {};
type CollectInFlightRequestInformationRouteParameters = {};
type CollectInFlightRequestInformationRequestHeaders = {};
type CollectInFlightRequestInformationRequestParameters = CollectInFlightRequestInformationRequestQuery & CollectInFlightRequestInformationRouteParameters & CollectInFlightRequestInformationRequestHeaders;
interface CollectInFlightRequestInformationOperation<STATUS extends keyof CollectInFlightRequestInformationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: CollectInFlightRequestInformationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: CollectInFlightRequestInformationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: CollectInFlightRequestInformationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: CollectInFlightRequestInformationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/read-initialization-status.type.d.ts
interface ReadInitializationStatusResponseBodies {
  200: void;
}
type ReadInitializationStatusRequestQuery = {};
type ReadInitializationStatusRouteParameters = {};
type ReadInitializationStatusRequestHeaders = {};
type ReadInitializationStatusRequestParameters = ReadInitializationStatusRequestQuery & ReadInitializationStatusRouteParameters & ReadInitializationStatusRequestHeaders;
interface ReadInitializationStatusOperation<STATUS extends keyof ReadInitializationStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: ReadInitializationStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: ReadInitializationStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: ReadInitializationStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: ReadInitializationStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/initialize-system-request.schema.d.ts
interface InitializeSystemRequest {
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys. Ordering is preserved. The keys must be base64-encoded from their original binary representation. The size of this array must be the same as `secret_shares`.
   */
  pgp_keys?: string[];
  /**
   * Specifies an array of PGP public keys used to encrypt the output recovery keys. Ordering is preserved. The keys must be base64-encoded from their original binary representation. The size of this array must be the same as `recovery_shares`.
   */
  recovery_pgp_keys?: string[];
  /**
   * Specifies the number of shares to split the recovery key into.
   */
  recovery_shares?: number;
  /**
   * Specifies the number of shares required to reconstruct the recovery key. This must be less than or equal to `recovery_shares`.
   */
  recovery_threshold?: number;
  /**
   * Specifies a PGP public key used to encrypt the initial root token. The key must be base64-encoded from its original binary representation.
   */
  root_token_pgp_key?: string;
  /**
   * Specifies the number of shares to split the unseal key into.
   */
  secret_shares?: number;
  /**
   * Specifies the number of shares required to reconstruct the unseal key. This must be less than or equal secret_shares. If using OpenBao HSM with auto-unsealing, this value must be the same as `secret_shares`.
   */
  secret_threshold?: number;
  /**
   * Specifies the number of shares that should be encrypted by the HSM and stored for auto-unsealing. Currently must be the same as `secret_shares`.
   */
  stored_shares?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/initialize-system.type.d.ts
interface InitializeSystemResponseBodies {
  200: void;
}
interface InitializeSystemRequestBodies {
  'application/json': InitializeSystemRequest;
}
type InitializeSystemRequestQuery = {};
type InitializeSystemRouteParameters = {};
type InitializeSystemRequestHeaders = {};
interface InitializeSystemParameterBodies {
  'application/json': InitializeSystemRequest & {
    [key: string]: any;
  };
}
type InitializeSystemRequestParameters = InitializeSystemRequestQuery & InitializeSystemRouteParameters & InitializeSystemRequestHeaders & InitializeSystemRequestBodies['application/json'];
interface InitializeSystemOperation<STATUS extends keyof InitializeSystemResponseBodies, CONTENT_TYPE extends keyof InitializeSystemParameterBodies> extends KeqOperation {
  requestParams: InitializeSystemRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: InitializeSystemRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: InitializeSystemRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: InitializeSystemParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: InitializeSystemResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-status.type.d.ts
interface EncryptionKeyStatusResponseBodies {
  200: void;
}
type EncryptionKeyStatusRequestQuery = {};
type EncryptionKeyStatusRouteParameters = {};
type EncryptionKeyStatusRequestHeaders = {};
type EncryptionKeyStatusRequestParameters = EncryptionKeyStatusRequestQuery & EncryptionKeyStatusRouteParameters & EncryptionKeyStatusRequestHeaders;
interface EncryptionKeyStatusOperation<STATUS extends keyof EncryptionKeyStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EncryptionKeyStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EncryptionKeyStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leader-status-response.schema.d.ts
interface LeaderStatusResponse {
  /**
   * @format date-time
   */
  active_time?: string;
  ha_enabled?: boolean;
  is_self?: boolean;
  /**
   * @format int64
   */
  last_wal?: number;
  leader_address?: string;
  leader_cluster_address?: string;
  performance_standby?: boolean;
  /**
   * @format int64
   */
  performance_standby_last_remote_wal?: number;
  /**
   * @format int64
   */
  raft_applied_index?: number;
  /**
   * @format int64
   */
  raft_committed_index?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leader-status.type.d.ts
interface LeaderStatusResponseBodies {
  200: LeaderStatusResponse;
}
type LeaderStatusRequestQuery = {};
type LeaderStatusRouteParameters = {};
type LeaderStatusRequestHeaders = {};
type LeaderStatusRequestParameters = LeaderStatusRequestQuery & LeaderStatusRouteParameters & LeaderStatusRequestHeaders;
interface LeaderStatusOperation<STATUS extends keyof LeaderStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeaderStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeaderStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeaderStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeaderStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-list-response.schema.d.ts
interface LeasesListResponse {
  /**
   * Number of matching leases per mount
   */
  counts?: number;
  /**
   * Number of matching leases
   */
  lease_count?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-list.type.d.ts
interface LeasesListResponseBodies {
  200: LeasesListResponse;
}
type LeasesListRequestQuery = {};
type LeasesListRouteParameters = {};
type LeasesListRequestHeaders = {};
type LeasesListRequestParameters = LeasesListRequestQuery & LeasesListRouteParameters & LeasesListRequestHeaders;
interface LeasesListOperation<STATUS extends keyof LeasesListResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesListRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesListRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesListRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesListResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-count-response.schema.d.ts
interface LeasesCountResponse {
  /**
   * Number of matching leases per mount
   */
  counts?: number;
  /**
   * Number of matching leases
   */
  lease_count?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-count.type.d.ts
interface LeasesCountResponseBodies {
  200: LeasesCountResponse;
}
type LeasesCountRequestQuery = {};
type LeasesCountRouteParameters = {};
type LeasesCountRequestHeaders = {};
type LeasesCountRequestParameters = LeasesCountRequestQuery & LeasesCountRouteParameters & LeasesCountRequestHeaders;
interface LeasesCountOperation<STATUS extends keyof LeasesCountResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesCountRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesCountRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesCountRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesCountResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-read-lease-request.schema.d.ts
interface LeasesReadLeaseRequest {
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  lease_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-read-lease-response.schema.d.ts
interface LeasesReadLeaseResponse {
  /**
   * Optional lease expiry time
   * @format date-time
   */
  expire_time?: string;
  /**
   * Lease id
   */
  id?: string;
  /**
   * Timestamp for the lease's issue time
   * @format date-time
   */
  issue_time?: string;
  /**
   * Optional Timestamp of the last time the lease was renewed
   * @format date-time
   */
  last_renewal?: string;
  /**
   * True if the lease is able to be renewed
   */
  renewable?: boolean;
  /**
   * Time to Live set for the lease, returns 0 if unset
   */
  ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-read-lease.type.d.ts
interface LeasesReadLeaseResponseBodies {
  200: LeasesReadLeaseResponse;
}
interface LeasesReadLeaseRequestBodies {
  'application/json': LeasesReadLeaseRequest;
}
type LeasesReadLeaseRequestQuery = {};
type LeasesReadLeaseRouteParameters = {};
type LeasesReadLeaseRequestHeaders = {};
interface LeasesReadLeaseParameterBodies {
  'application/json': LeasesReadLeaseRequest & {
    [key: string]: any;
  };
}
type LeasesReadLeaseRequestParameters = LeasesReadLeaseRequestQuery & LeasesReadLeaseRouteParameters & LeasesReadLeaseRequestHeaders & LeasesReadLeaseRequestBodies['application/json'];
interface LeasesReadLeaseOperation<STATUS extends keyof LeasesReadLeaseResponseBodies, CONTENT_TYPE extends keyof LeasesReadLeaseParameterBodies> extends KeqOperation {
  requestParams: LeasesReadLeaseRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesReadLeaseRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesReadLeaseRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesReadLeaseParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesReadLeaseResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-look-up-response.schema.d.ts
interface LeasesLookUpResponse {
  /**
   * A list of lease ids
   */
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-look-up.type.d.ts
interface LeasesLookUpResponseBodies {
  200: LeasesLookUpResponse;
}
type LeasesLookUpRequestQuery = {
  list: ('true');
};
type LeasesLookUpRouteParameters = {};
type LeasesLookUpRequestHeaders = {};
type LeasesLookUpRequestParameters = LeasesLookUpRequestQuery & LeasesLookUpRouteParameters & LeasesLookUpRequestHeaders;
interface LeasesLookUpOperation<STATUS extends keyof LeasesLookUpResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesLookUpRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesLookUpRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesLookUpRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesLookUpResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-look-up-with-prefix-response.schema.d.ts
interface LeasesLookUpWithPrefixResponse {
  /**
   * A list of lease ids
   */
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-look-up-with-prefix.type.d.ts
interface LeasesLookUpWithPrefixResponseBodies {
  200: LeasesLookUpWithPrefixResponse;
}
type LeasesLookUpWithPrefixRequestQuery = {
  list: ('true');
};
type LeasesLookUpWithPrefixRouteParameters = {};
type LeasesLookUpWithPrefixRequestHeaders = {};
type LeasesLookUpWithPrefixRequestParameters = LeasesLookUpWithPrefixRequestQuery & LeasesLookUpWithPrefixRouteParameters & LeasesLookUpWithPrefixRequestHeaders;
interface LeasesLookUpWithPrefixOperation<STATUS extends keyof LeasesLookUpWithPrefixResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesLookUpWithPrefixRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesLookUpWithPrefixRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesLookUpWithPrefixRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesLookUpWithPrefixResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-renew-lease-request.schema.d.ts
interface LeasesRenewLeaseRequest {
  /**
   * The desired increment in seconds to the lease
   * @format seconds
   */
  increment?: number;
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  lease_id?: string;
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  url_lease_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-renew-lease.type.d.ts
interface LeasesRenewLeaseResponseBodies {
  204: void;
}
interface LeasesRenewLeaseRequestBodies {
  'application/json': LeasesRenewLeaseRequest;
}
type LeasesRenewLeaseRequestQuery = {};
type LeasesRenewLeaseRouteParameters = {};
type LeasesRenewLeaseRequestHeaders = {};
interface LeasesRenewLeaseParameterBodies {
  'application/json': LeasesRenewLeaseRequest & {
    [key: string]: any;
  };
}
type LeasesRenewLeaseRequestParameters = LeasesRenewLeaseRequestQuery & LeasesRenewLeaseRouteParameters & LeasesRenewLeaseRequestHeaders & LeasesRenewLeaseRequestBodies['application/json'];
interface LeasesRenewLeaseOperation<STATUS extends keyof LeasesRenewLeaseResponseBodies, CONTENT_TYPE extends keyof LeasesRenewLeaseParameterBodies> extends KeqOperation {
  requestParams: LeasesRenewLeaseRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesRenewLeaseRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesRenewLeaseRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesRenewLeaseParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesRenewLeaseResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-renew-lease-with-id-request.schema.d.ts
interface LeasesRenewLeaseWithIdRequest {
  /**
   * The desired increment in seconds to the lease
   * @format seconds
   */
  increment?: number;
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  lease_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-renew-lease-with-id.type.d.ts
interface LeasesRenewLeaseWithIdResponseBodies {
  204: void;
}
interface LeasesRenewLeaseWithIdRequestBodies {
  'application/json': LeasesRenewLeaseWithIdRequest;
}
type LeasesRenewLeaseWithIdRequestQuery = {};
type LeasesRenewLeaseWithIdRouteParameters = {};
type LeasesRenewLeaseWithIdRequestHeaders = {};
interface LeasesRenewLeaseWithIdParameterBodies {
  'application/json': LeasesRenewLeaseWithIdRequest & {
    [key: string]: any;
  };
}
type LeasesRenewLeaseWithIdRequestParameters = LeasesRenewLeaseWithIdRequestQuery & LeasesRenewLeaseWithIdRouteParameters & LeasesRenewLeaseWithIdRequestHeaders & LeasesRenewLeaseWithIdRequestBodies['application/json'];
interface LeasesRenewLeaseWithIdOperation<STATUS extends keyof LeasesRenewLeaseWithIdResponseBodies, CONTENT_TYPE extends keyof LeasesRenewLeaseWithIdParameterBodies> extends KeqOperation {
  requestParams: LeasesRenewLeaseWithIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesRenewLeaseWithIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesRenewLeaseWithIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesRenewLeaseWithIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesRenewLeaseWithIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-revoke-lease-request.schema.d.ts
interface LeasesRevokeLeaseRequest {
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  lease_id?: string;
  /**
   * Whether or not to perform the revocation synchronously
   */
  sync?: boolean;
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  url_lease_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-revoke-lease.type.d.ts
interface LeasesRevokeLeaseResponseBodies {
  204: void;
}
interface LeasesRevokeLeaseRequestBodies {
  'application/json': LeasesRevokeLeaseRequest;
}
type LeasesRevokeLeaseRequestQuery = {};
type LeasesRevokeLeaseRouteParameters = {};
type LeasesRevokeLeaseRequestHeaders = {};
interface LeasesRevokeLeaseParameterBodies {
  'application/json': LeasesRevokeLeaseRequest & {
    [key: string]: any;
  };
}
type LeasesRevokeLeaseRequestParameters = LeasesRevokeLeaseRequestQuery & LeasesRevokeLeaseRouteParameters & LeasesRevokeLeaseRequestHeaders & LeasesRevokeLeaseRequestBodies['application/json'];
interface LeasesRevokeLeaseOperation<STATUS extends keyof LeasesRevokeLeaseResponseBodies, CONTENT_TYPE extends keyof LeasesRevokeLeaseParameterBodies> extends KeqOperation {
  requestParams: LeasesRevokeLeaseRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesRevokeLeaseRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesRevokeLeaseRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesRevokeLeaseParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesRevokeLeaseResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-force-revoke-lease-with-prefix.type.d.ts
interface LeasesForceRevokeLeaseWithPrefixResponseBodies {
  204: void;
}
type LeasesForceRevokeLeaseWithPrefixRequestQuery = {};
type LeasesForceRevokeLeaseWithPrefixRouteParameters = {};
type LeasesForceRevokeLeaseWithPrefixRequestHeaders = {};
type LeasesForceRevokeLeaseWithPrefixRequestParameters = LeasesForceRevokeLeaseWithPrefixRequestQuery & LeasesForceRevokeLeaseWithPrefixRouteParameters & LeasesForceRevokeLeaseWithPrefixRequestHeaders;
interface LeasesForceRevokeLeaseWithPrefixOperation<STATUS extends keyof LeasesForceRevokeLeaseWithPrefixResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesForceRevokeLeaseWithPrefixRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesForceRevokeLeaseWithPrefixRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesForceRevokeLeaseWithPrefixRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesForceRevokeLeaseWithPrefixResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-revoke-lease-with-prefix-request.schema.d.ts
interface LeasesRevokeLeaseWithPrefixRequest {
  /**
   * Whether or not to perform the revocation synchronously
   */
  sync?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-revoke-lease-with-prefix.type.d.ts
interface LeasesRevokeLeaseWithPrefixResponseBodies {
  204: void;
}
interface LeasesRevokeLeaseWithPrefixRequestBodies {
  'application/json': LeasesRevokeLeaseWithPrefixRequest;
}
type LeasesRevokeLeaseWithPrefixRequestQuery = {};
type LeasesRevokeLeaseWithPrefixRouteParameters = {};
type LeasesRevokeLeaseWithPrefixRequestHeaders = {};
interface LeasesRevokeLeaseWithPrefixParameterBodies {
  'application/json': LeasesRevokeLeaseWithPrefixRequest & {
    [key: string]: any;
  };
}
type LeasesRevokeLeaseWithPrefixRequestParameters = LeasesRevokeLeaseWithPrefixRequestQuery & LeasesRevokeLeaseWithPrefixRouteParameters & LeasesRevokeLeaseWithPrefixRequestHeaders & LeasesRevokeLeaseWithPrefixRequestBodies['application/json'];
interface LeasesRevokeLeaseWithPrefixOperation<STATUS extends keyof LeasesRevokeLeaseWithPrefixResponseBodies, CONTENT_TYPE extends keyof LeasesRevokeLeaseWithPrefixParameterBodies> extends KeqOperation {
  requestParams: LeasesRevokeLeaseWithPrefixRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesRevokeLeaseWithPrefixRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesRevokeLeaseWithPrefixRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesRevokeLeaseWithPrefixParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesRevokeLeaseWithPrefixResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/leases-revoke-lease-with-id-request.schema.d.ts
interface LeasesRevokeLeaseWithIdRequest {
  /**
   * The lease identifier to renew. This is included with a lease.
   */
  lease_id?: string;
  /**
   * Whether or not to perform the revocation synchronously
   */
  sync?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-revoke-lease-with-id.type.d.ts
interface LeasesRevokeLeaseWithIdResponseBodies {
  204: void;
}
interface LeasesRevokeLeaseWithIdRequestBodies {
  'application/json': LeasesRevokeLeaseWithIdRequest;
}
type LeasesRevokeLeaseWithIdRequestQuery = {};
type LeasesRevokeLeaseWithIdRouteParameters = {};
type LeasesRevokeLeaseWithIdRequestHeaders = {};
interface LeasesRevokeLeaseWithIdParameterBodies {
  'application/json': LeasesRevokeLeaseWithIdRequest & {
    [key: string]: any;
  };
}
type LeasesRevokeLeaseWithIdRequestParameters = LeasesRevokeLeaseWithIdRequestQuery & LeasesRevokeLeaseWithIdRouteParameters & LeasesRevokeLeaseWithIdRequestHeaders & LeasesRevokeLeaseWithIdRequestBodies['application/json'];
interface LeasesRevokeLeaseWithIdOperation<STATUS extends keyof LeasesRevokeLeaseWithIdResponseBodies, CONTENT_TYPE extends keyof LeasesRevokeLeaseWithIdParameterBodies> extends KeqOperation {
  requestParams: LeasesRevokeLeaseWithIdRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesRevokeLeaseWithIdRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesRevokeLeaseWithIdRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LeasesRevokeLeaseWithIdParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LeasesRevokeLeaseWithIdResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/leases-tidy.type.d.ts
interface LeasesTidyResponseBodies {
  204: void;
}
type LeasesTidyRequestQuery = {};
type LeasesTidyRouteParameters = {};
type LeasesTidyRequestHeaders = {};
type LeasesTidyRequestParameters = LeasesTidyRequestQuery & LeasesTidyRouteParameters & LeasesTidyRequestHeaders;
interface LeasesTidyOperation<STATUS extends keyof LeasesTidyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LeasesTidyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LeasesTidyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LeasesTidyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LeasesTidyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/locked-users-list.type.d.ts
interface LockedUsersListResponseBodies {
  200: void;
}
type LockedUsersListRequestQuery = {};
type LockedUsersListRouteParameters = {};
type LockedUsersListRequestHeaders = {};
type LockedUsersListRequestParameters = LockedUsersListRequestQuery & LockedUsersListRouteParameters & LockedUsersListRequestHeaders;
interface LockedUsersListOperation<STATUS extends keyof LockedUsersListResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LockedUsersListRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LockedUsersListRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LockedUsersListRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LockedUsersListResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/locked-users-unlock.type.d.ts
interface LockedUsersUnlockResponseBodies {
  200: void;
}
type LockedUsersUnlockRequestQuery = {};
type LockedUsersUnlockRouteParameters = {};
type LockedUsersUnlockRequestHeaders = {};
type LockedUsersUnlockRequestParameters = LockedUsersUnlockRequestQuery & LockedUsersUnlockRouteParameters & LockedUsersUnlockRequestHeaders;
interface LockedUsersUnlockOperation<STATUS extends keyof LockedUsersUnlockResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LockedUsersUnlockRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LockedUsersUnlockRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LockedUsersUnlockRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LockedUsersUnlockResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-read-verbosity-level.type.d.ts
interface LoggersReadVerbosityLevelResponseBodies {
  200: void;
}
type LoggersReadVerbosityLevelRequestQuery = {};
type LoggersReadVerbosityLevelRouteParameters = {};
type LoggersReadVerbosityLevelRequestHeaders = {};
type LoggersReadVerbosityLevelRequestParameters = LoggersReadVerbosityLevelRequestQuery & LoggersReadVerbosityLevelRouteParameters & LoggersReadVerbosityLevelRequestHeaders;
interface LoggersReadVerbosityLevelOperation<STATUS extends keyof LoggersReadVerbosityLevelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LoggersReadVerbosityLevelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersReadVerbosityLevelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersReadVerbosityLevelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LoggersReadVerbosityLevelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/loggers-update-verbosity-level-request.schema.d.ts
interface LoggersUpdateVerbosityLevelRequest {
  /**
   * Log verbosity level. Supported values (in order of detail) are "trace", "debug", "info", "warn", and "error".
   */
  level?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-update-verbosity-level.type.d.ts
interface LoggersUpdateVerbosityLevelResponseBodies {
  204: void;
}
interface LoggersUpdateVerbosityLevelRequestBodies {
  'application/json': LoggersUpdateVerbosityLevelRequest;
}
type LoggersUpdateVerbosityLevelRequestQuery = {};
type LoggersUpdateVerbosityLevelRouteParameters = {};
type LoggersUpdateVerbosityLevelRequestHeaders = {};
interface LoggersUpdateVerbosityLevelParameterBodies {
  'application/json': LoggersUpdateVerbosityLevelRequest & {
    [key: string]: any;
  };
}
type LoggersUpdateVerbosityLevelRequestParameters = LoggersUpdateVerbosityLevelRequestQuery & LoggersUpdateVerbosityLevelRouteParameters & LoggersUpdateVerbosityLevelRequestHeaders & LoggersUpdateVerbosityLevelRequestBodies['application/json'];
interface LoggersUpdateVerbosityLevelOperation<STATUS extends keyof LoggersUpdateVerbosityLevelResponseBodies, CONTENT_TYPE extends keyof LoggersUpdateVerbosityLevelParameterBodies> extends KeqOperation {
  requestParams: LoggersUpdateVerbosityLevelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersUpdateVerbosityLevelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersUpdateVerbosityLevelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LoggersUpdateVerbosityLevelParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LoggersUpdateVerbosityLevelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-revert-verbosity-level.type.d.ts
interface LoggersRevertVerbosityLevelResponseBodies {
  204: void;
}
type LoggersRevertVerbosityLevelRequestQuery = {};
type LoggersRevertVerbosityLevelRouteParameters = {};
type LoggersRevertVerbosityLevelRequestHeaders = {};
type LoggersRevertVerbosityLevelRequestParameters = LoggersRevertVerbosityLevelRequestQuery & LoggersRevertVerbosityLevelRouteParameters & LoggersRevertVerbosityLevelRequestHeaders;
interface LoggersRevertVerbosityLevelOperation<STATUS extends keyof LoggersRevertVerbosityLevelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LoggersRevertVerbosityLevelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersRevertVerbosityLevelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersRevertVerbosityLevelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LoggersRevertVerbosityLevelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-read-verbosity-level-for.type.d.ts
interface LoggersReadVerbosityLevelForResponseBodies {
  200: void;
}
type LoggersReadVerbosityLevelForRequestQuery = {};
type LoggersReadVerbosityLevelForRouteParameters = {};
type LoggersReadVerbosityLevelForRequestHeaders = {};
type LoggersReadVerbosityLevelForRequestParameters = LoggersReadVerbosityLevelForRequestQuery & LoggersReadVerbosityLevelForRouteParameters & LoggersReadVerbosityLevelForRequestHeaders;
interface LoggersReadVerbosityLevelForOperation<STATUS extends keyof LoggersReadVerbosityLevelForResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LoggersReadVerbosityLevelForRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersReadVerbosityLevelForRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersReadVerbosityLevelForRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LoggersReadVerbosityLevelForResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/loggers-update-verbosity-level-for-request.schema.d.ts
interface LoggersUpdateVerbosityLevelForRequest {
  /**
   * Log verbosity level. Supported values (in order of detail) are "trace", "debug", "info", "warn", and "error".
   */
  level?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-update-verbosity-level-for.type.d.ts
interface LoggersUpdateVerbosityLevelForResponseBodies {
  204: void;
}
interface LoggersUpdateVerbosityLevelForRequestBodies {
  'application/json': LoggersUpdateVerbosityLevelForRequest;
}
type LoggersUpdateVerbosityLevelForRequestQuery = {};
type LoggersUpdateVerbosityLevelForRouteParameters = {};
type LoggersUpdateVerbosityLevelForRequestHeaders = {};
interface LoggersUpdateVerbosityLevelForParameterBodies {
  'application/json': LoggersUpdateVerbosityLevelForRequest & {
    [key: string]: any;
  };
}
type LoggersUpdateVerbosityLevelForRequestParameters = LoggersUpdateVerbosityLevelForRequestQuery & LoggersUpdateVerbosityLevelForRouteParameters & LoggersUpdateVerbosityLevelForRequestHeaders & LoggersUpdateVerbosityLevelForRequestBodies['application/json'];
interface LoggersUpdateVerbosityLevelForOperation<STATUS extends keyof LoggersUpdateVerbosityLevelForResponseBodies, CONTENT_TYPE extends keyof LoggersUpdateVerbosityLevelForParameterBodies> extends KeqOperation {
  requestParams: LoggersUpdateVerbosityLevelForRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersUpdateVerbosityLevelForRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersUpdateVerbosityLevelForRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: LoggersUpdateVerbosityLevelForParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: LoggersUpdateVerbosityLevelForResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/loggers-revert-verbosity-level-for.type.d.ts
interface LoggersRevertVerbosityLevelForResponseBodies {
  204: void;
}
type LoggersRevertVerbosityLevelForRequestQuery = {};
type LoggersRevertVerbosityLevelForRouteParameters = {};
type LoggersRevertVerbosityLevelForRequestHeaders = {};
type LoggersRevertVerbosityLevelForRequestParameters = LoggersRevertVerbosityLevelForRequestQuery & LoggersRevertVerbosityLevelForRouteParameters & LoggersRevertVerbosityLevelForRequestHeaders;
interface LoggersRevertVerbosityLevelForOperation<STATUS extends keyof LoggersRevertVerbosityLevelForResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: LoggersRevertVerbosityLevelForRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: LoggersRevertVerbosityLevelForRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: LoggersRevertVerbosityLevelForRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: LoggersRevertVerbosityLevelForResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/metrics.type.d.ts
interface MetricsResponseBodies {
  200: void;
}
type MetricsRequestQuery = {};
type MetricsRouteParameters = {};
type MetricsRequestHeaders = {};
type MetricsRequestParameters = MetricsRequestQuery & MetricsRouteParameters & MetricsRequestHeaders;
interface MetricsOperation<STATUS extends keyof MetricsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MetricsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MetricsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MetricsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MetricsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mfa-validate-request.schema.d.ts
interface MfaValidateRequest {
  /**
   * A map from MFA method ID to a slice of passcodes or an empty slice if the method does not use passcodes
   * @format map
   */
  mfa_payload: Record<string, never>;
  /**
   * ID for this MFA request
   */
  mfa_request_id: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mfa-validate.type.d.ts
interface MfaValidateResponseBodies {
  200: void;
}
interface MfaValidateRequestBodies {
  'application/json': MfaValidateRequest;
}
type MfaValidateRequestQuery = {};
type MfaValidateRouteParameters = {};
type MfaValidateRequestHeaders = {};
interface MfaValidateParameterBodies {
  'application/json': MfaValidateRequest & {
    [key: string]: any;
  };
}
type MfaValidateRequestParameters = MfaValidateRequestQuery & MfaValidateRouteParameters & MfaValidateRequestHeaders & MfaValidateRequestBodies['application/json'];
interface MfaValidateOperation<STATUS extends keyof MfaValidateResponseBodies, CONTENT_TYPE extends keyof MfaValidateParameterBodies> extends KeqOperation {
  requestParams: MfaValidateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MfaValidateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MfaValidateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MfaValidateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MfaValidateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/monitor.type.d.ts
interface MonitorResponseBodies {
  200: void;
}
type MonitorRequestQuery = {};
type MonitorRouteParameters = {};
type MonitorRequestHeaders = {};
type MonitorRequestParameters = MonitorRequestQuery & MonitorRouteParameters & MonitorRequestHeaders;
interface MonitorOperation<STATUS extends keyof MonitorResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MonitorRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MonitorRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MonitorRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MonitorResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-list-secrets-engines.type.d.ts
interface MountsListSecretsEnginesResponseBodies {
  200: void;
}
type MountsListSecretsEnginesRequestQuery = {};
type MountsListSecretsEnginesRouteParameters = {};
type MountsListSecretsEnginesRequestHeaders = {};
type MountsListSecretsEnginesRequestParameters = MountsListSecretsEnginesRequestQuery & MountsListSecretsEnginesRouteParameters & MountsListSecretsEnginesRequestHeaders;
interface MountsListSecretsEnginesOperation<STATUS extends keyof MountsListSecretsEnginesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MountsListSecretsEnginesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsListSecretsEnginesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsListSecretsEnginesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MountsListSecretsEnginesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mounts-read-configuration-response.schema.d.ts
interface MountsReadConfigurationResponse {
  accessor?: string;
  /**
   * Configuration for this mount, such as default_lease_ttl and max_lease_ttl.
   * @format map
   */
  config?: Record<string, never>;
  deprecation_status?: string;
  /**
   * User-friendly description for this mount.
   */
  description?: string;
  external_entropy_access?: boolean;
  /**
   * Mark the mount as a local mount, which is not replicated and is unaffected by replication.
   */
  local?: boolean;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  running_plugin_version?: string;
  running_sha256?: string;
  /**
   * Whether to turn on seal wrapping for the mount.
   */
  seal_wrap?: boolean;
  /**
   * The type of the backend. Example: "passthrough"
   */
  type?: string;
  uuid?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-read-configuration.type.d.ts
interface MountsReadConfigurationResponseBodies {
  200: MountsReadConfigurationResponse;
}
type MountsReadConfigurationRequestQuery = {};
type MountsReadConfigurationRouteParameters = {};
type MountsReadConfigurationRequestHeaders = {};
type MountsReadConfigurationRequestParameters = MountsReadConfigurationRequestQuery & MountsReadConfigurationRouteParameters & MountsReadConfigurationRequestHeaders;
interface MountsReadConfigurationOperation<STATUS extends keyof MountsReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MountsReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MountsReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mounts-enable-secrets-engine-request.schema.d.ts
interface MountsEnableSecretsEngineRequest {
  /**
   * Configuration for this mount, such as default_lease_ttl and max_lease_ttl.
   * @format map
   */
  config?: Record<string, never>;
  /**
   * User-friendly description for this mount.
   */
  description?: string;
  /**
   * Whether to give the mount access to OpenBao's external entropy.
   */
  external_entropy_access?: boolean;
  /**
   * Mark the mount as a local mount, which is not replicated and is unaffected by replication.
   */
  local?: boolean;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * Name of the plugin to mount based from the name registered in the plugin catalog.
   */
  plugin_name?: string;
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  /**
   * Whether to turn on seal wrapping for the mount.
   */
  seal_wrap?: boolean;
  /**
   * The type of the backend. Example: "passthrough"
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-enable-secrets-engine.type.d.ts
interface MountsEnableSecretsEngineResponseBodies {
  204: void;
}
interface MountsEnableSecretsEngineRequestBodies {
  'application/json': MountsEnableSecretsEngineRequest;
}
type MountsEnableSecretsEngineRequestQuery = {};
type MountsEnableSecretsEngineRouteParameters = {};
type MountsEnableSecretsEngineRequestHeaders = {};
interface MountsEnableSecretsEngineParameterBodies {
  'application/json': MountsEnableSecretsEngineRequest & {
    [key: string]: any;
  };
}
type MountsEnableSecretsEngineRequestParameters = MountsEnableSecretsEngineRequestQuery & MountsEnableSecretsEngineRouteParameters & MountsEnableSecretsEngineRequestHeaders & MountsEnableSecretsEngineRequestBodies['application/json'];
interface MountsEnableSecretsEngineOperation<STATUS extends keyof MountsEnableSecretsEngineResponseBodies, CONTENT_TYPE extends keyof MountsEnableSecretsEngineParameterBodies> extends KeqOperation {
  requestParams: MountsEnableSecretsEngineRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsEnableSecretsEngineRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsEnableSecretsEngineRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MountsEnableSecretsEngineParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MountsEnableSecretsEngineResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-disable-secrets-engine.type.d.ts
interface MountsDisableSecretsEngineResponseBodies {
  200: void;
}
type MountsDisableSecretsEngineRequestQuery = {};
type MountsDisableSecretsEngineRouteParameters = {};
type MountsDisableSecretsEngineRequestHeaders = {};
type MountsDisableSecretsEngineRequestParameters = MountsDisableSecretsEngineRequestQuery & MountsDisableSecretsEngineRouteParameters & MountsDisableSecretsEngineRequestHeaders;
interface MountsDisableSecretsEngineOperation<STATUS extends keyof MountsDisableSecretsEngineResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MountsDisableSecretsEngineRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsDisableSecretsEngineRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsDisableSecretsEngineRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MountsDisableSecretsEngineResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mounts-read-tuning-information-response.schema.d.ts
interface MountsReadTuningInformationResponse {
  allowed_managed_keys?: string[];
  /**
   * A list of headers to whitelist and allow a plugin to set on responses.
   */
  allowed_response_headers?: string[];
  audit_non_hmac_request_keys?: string[];
  audit_non_hmac_response_keys?: string[];
  /**
   * The default lease TTL for this mount.
   */
  default_lease_ttl?: number;
  /**
   * User-friendly description for this credential backend.
   */
  description?: string;
  external_entropy_access?: boolean;
  force_no_cache?: boolean;
  listing_visibility?: string;
  /**
   * The max lease TTL for this mount.
   */
  max_lease_ttl?: number;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  passthrough_request_headers?: string[];
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  /**
   * The type of token to issue (service or batch).
   */
  token_type?: string;
  /**
   * @format int64
   */
  user_lockout_counter_reset_duration?: number;
  user_lockout_disable?: boolean;
  /**
   * @format int64
   */
  user_lockout_duration?: number;
  /**
   * @format int64
   */
  user_lockout_threshold?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-read-tuning-information.type.d.ts
interface MountsReadTuningInformationResponseBodies {
  200: MountsReadTuningInformationResponse;
}
type MountsReadTuningInformationRequestQuery = {};
type MountsReadTuningInformationRouteParameters = {};
type MountsReadTuningInformationRequestHeaders = {};
type MountsReadTuningInformationRequestParameters = MountsReadTuningInformationRequestQuery & MountsReadTuningInformationRouteParameters & MountsReadTuningInformationRequestHeaders;
interface MountsReadTuningInformationOperation<STATUS extends keyof MountsReadTuningInformationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: MountsReadTuningInformationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsReadTuningInformationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsReadTuningInformationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: MountsReadTuningInformationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/mounts-tune-configuration-parameters-request.schema.d.ts
interface MountsTuneConfigurationParametersRequest {
  allowed_managed_keys?: string[];
  /**
   * A list of headers to whitelist and allow a plugin to set on responses.
   */
  allowed_response_headers?: string[];
  /**
   * The list of keys in the request data object that will not be HMAC'ed by audit devices.
   */
  audit_non_hmac_request_keys?: string[];
  /**
   * The list of keys in the response data object that will not be HMAC'ed by audit devices.
   */
  audit_non_hmac_response_keys?: string[];
  /**
   * The default lease TTL for this mount.
   */
  default_lease_ttl?: string;
  /**
   * User-friendly description for this credential backend.
   */
  description?: string;
  /**
   * Determines the visibility of the mount in the UI-specific listing endpoint. Accepted value are 'unauth' and 'hidden', with the empty default ('') behaving like 'hidden'.
   */
  listing_visibility?: string;
  /**
   * The max lease TTL for this mount.
   */
  max_lease_ttl?: string;
  /**
   * The options to pass into the backend. Should be a json object with string keys and values.
   * @format kvpairs
   */
  options?: Record<string, never>;
  /**
   * A list of headers to whitelist and pass from the request to the plugin.
   */
  passthrough_request_headers?: string[];
  /**
   * The semantic version of the plugin to use.
   */
  plugin_version?: string;
  /**
   * The type of token to issue (service or batch).
   */
  token_type?: string;
  /**
   * The user lockout configuration to pass into the backend. Should be a json object with string keys and values.
   * @format map
   */
  user_lockout_config?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/mounts-tune-configuration-parameters.type.d.ts
interface MountsTuneConfigurationParametersResponseBodies {
  200: void;
}
interface MountsTuneConfigurationParametersRequestBodies {
  'application/json': MountsTuneConfigurationParametersRequest;
}
type MountsTuneConfigurationParametersRequestQuery = {};
type MountsTuneConfigurationParametersRouteParameters = {};
type MountsTuneConfigurationParametersRequestHeaders = {};
interface MountsTuneConfigurationParametersParameterBodies {
  'application/json': MountsTuneConfigurationParametersRequest & {
    [key: string]: any;
  };
}
type MountsTuneConfigurationParametersRequestParameters = MountsTuneConfigurationParametersRequestQuery & MountsTuneConfigurationParametersRouteParameters & MountsTuneConfigurationParametersRequestHeaders & MountsTuneConfigurationParametersRequestBodies['application/json'];
interface MountsTuneConfigurationParametersOperation<STATUS extends keyof MountsTuneConfigurationParametersResponseBodies, CONTENT_TYPE extends keyof MountsTuneConfigurationParametersParameterBodies> extends KeqOperation {
  requestParams: MountsTuneConfigurationParametersRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: MountsTuneConfigurationParametersRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: MountsTuneConfigurationParametersRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: MountsTuneConfigurationParametersParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: MountsTuneConfigurationParametersResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-list-namespaces-response.schema.d.ts
interface NamespacesListNamespacesResponse {
  /**
   * Map of namespace details by path.
   * @format map
   */
  key_info?: Record<string, never>;
  /**
   * List of namespace paths.
   */
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-list-namespaces.type.d.ts
interface NamespacesListNamespacesResponseBodies {
  200: NamespacesListNamespacesResponse;
}
type NamespacesListNamespacesRequestQuery = {
  list: ('true');
};
type NamespacesListNamespacesRouteParameters = {};
type NamespacesListNamespacesRequestHeaders = {};
type NamespacesListNamespacesRequestParameters = NamespacesListNamespacesRequestQuery & NamespacesListNamespacesRouteParameters & NamespacesListNamespacesRequestHeaders;
interface NamespacesListNamespacesOperation<STATUS extends keyof NamespacesListNamespacesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: NamespacesListNamespacesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesListNamespacesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesListNamespacesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: NamespacesListNamespacesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-api-lock-lock-request.schema.d.ts
interface NamespacesWriteNamespacesApiLockLockRequest {
  /**
   * Path of the namespace.
   */
  path?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-api-lock-lock-response.schema.d.ts
interface NamespacesWriteNamespacesApiLockLockResponse {
  /**
   * Unlock key required for unlocking the namespace.
   */
  unlock_key?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-write-namespaces-api-lock-lock.type.d.ts
interface NamespacesWriteNamespacesApiLockLockResponseBodies {
  200: NamespacesWriteNamespacesApiLockLockResponse;
}
interface NamespacesWriteNamespacesApiLockLockRequestBodies {
  'application/json': NamespacesWriteNamespacesApiLockLockRequest;
}
type NamespacesWriteNamespacesApiLockLockRequestQuery = {};
type NamespacesWriteNamespacesApiLockLockRouteParameters = {};
type NamespacesWriteNamespacesApiLockLockRequestHeaders = {};
interface NamespacesWriteNamespacesApiLockLockParameterBodies {
  'application/json': NamespacesWriteNamespacesApiLockLockRequest & {
    [key: string]: any;
  };
}
type NamespacesWriteNamespacesApiLockLockRequestParameters = NamespacesWriteNamespacesApiLockLockRequestQuery & NamespacesWriteNamespacesApiLockLockRouteParameters & NamespacesWriteNamespacesApiLockLockRequestHeaders & NamespacesWriteNamespacesApiLockLockRequestBodies['application/json'];
interface NamespacesWriteNamespacesApiLockLockOperation<STATUS extends keyof NamespacesWriteNamespacesApiLockLockResponseBodies, CONTENT_TYPE extends keyof NamespacesWriteNamespacesApiLockLockParameterBodies> extends KeqOperation {
  requestParams: NamespacesWriteNamespacesApiLockLockRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesWriteNamespacesApiLockLockRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesWriteNamespacesApiLockLockRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: NamespacesWriteNamespacesApiLockLockParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: NamespacesWriteNamespacesApiLockLockResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-api-lock-lock-path-response.schema.d.ts
interface NamespacesWriteNamespacesApiLockLockPathResponse {
  /**
   * Unlock key required for unlocking the namespace.
   */
  unlock_key?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-write-namespaces-api-lock-lock-path.type.d.ts
interface NamespacesWriteNamespacesApiLockLockPathResponseBodies {
  200: NamespacesWriteNamespacesApiLockLockPathResponse;
}
type NamespacesWriteNamespacesApiLockLockPathRequestQuery = {};
type NamespacesWriteNamespacesApiLockLockPathRouteParameters = {};
type NamespacesWriteNamespacesApiLockLockPathRequestHeaders = {};
type NamespacesWriteNamespacesApiLockLockPathRequestParameters = NamespacesWriteNamespacesApiLockLockPathRequestQuery & NamespacesWriteNamespacesApiLockLockPathRouteParameters & NamespacesWriteNamespacesApiLockLockPathRequestHeaders;
interface NamespacesWriteNamespacesApiLockLockPathOperation<STATUS extends keyof NamespacesWriteNamespacesApiLockLockPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: NamespacesWriteNamespacesApiLockLockPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesWriteNamespacesApiLockLockPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesWriteNamespacesApiLockLockPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: NamespacesWriteNamespacesApiLockLockPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-api-lock-unlock-request.schema.d.ts
interface NamespacesWriteNamespacesApiLockUnlockRequest {
  /**
   * Path of the namespace.
   */
  path?: string;
  /**
   * Unlock key required for unlocking the namespace
   */
  unlock_key: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-write-namespaces-api-lock-unlock.type.d.ts
interface NamespacesWriteNamespacesApiLockUnlockResponseBodies {
  204: void;
}
interface NamespacesWriteNamespacesApiLockUnlockRequestBodies {
  'application/json': NamespacesWriteNamespacesApiLockUnlockRequest;
}
type NamespacesWriteNamespacesApiLockUnlockRequestQuery = {};
type NamespacesWriteNamespacesApiLockUnlockRouteParameters = {};
type NamespacesWriteNamespacesApiLockUnlockRequestHeaders = {};
interface NamespacesWriteNamespacesApiLockUnlockParameterBodies {
  'application/json': NamespacesWriteNamespacesApiLockUnlockRequest & {
    [key: string]: any;
  };
}
type NamespacesWriteNamespacesApiLockUnlockRequestParameters = NamespacesWriteNamespacesApiLockUnlockRequestQuery & NamespacesWriteNamespacesApiLockUnlockRouteParameters & NamespacesWriteNamespacesApiLockUnlockRequestHeaders & NamespacesWriteNamespacesApiLockUnlockRequestBodies['application/json'];
interface NamespacesWriteNamespacesApiLockUnlockOperation<STATUS extends keyof NamespacesWriteNamespacesApiLockUnlockResponseBodies, CONTENT_TYPE extends keyof NamespacesWriteNamespacesApiLockUnlockParameterBodies> extends KeqOperation {
  requestParams: NamespacesWriteNamespacesApiLockUnlockRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesWriteNamespacesApiLockUnlockRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesWriteNamespacesApiLockUnlockRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: NamespacesWriteNamespacesApiLockUnlockParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: NamespacesWriteNamespacesApiLockUnlockResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-api-lock-unlock-path-request.schema.d.ts
interface NamespacesWriteNamespacesApiLockUnlockPathRequest {
  /**
   * Unlock key required for unlocking the namespace
   */
  unlock_key: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-write-namespaces-api-lock-unlock-path.type.d.ts
interface NamespacesWriteNamespacesApiLockUnlockPathResponseBodies {
  204: void;
}
interface NamespacesWriteNamespacesApiLockUnlockPathRequestBodies {
  'application/json': NamespacesWriteNamespacesApiLockUnlockPathRequest;
}
type NamespacesWriteNamespacesApiLockUnlockPathRequestQuery = {};
type NamespacesWriteNamespacesApiLockUnlockPathRouteParameters = {};
type NamespacesWriteNamespacesApiLockUnlockPathRequestHeaders = {};
interface NamespacesWriteNamespacesApiLockUnlockPathParameterBodies {
  'application/json': NamespacesWriteNamespacesApiLockUnlockPathRequest & {
    [key: string]: any;
  };
}
type NamespacesWriteNamespacesApiLockUnlockPathRequestParameters = NamespacesWriteNamespacesApiLockUnlockPathRequestQuery & NamespacesWriteNamespacesApiLockUnlockPathRouteParameters & NamespacesWriteNamespacesApiLockUnlockPathRequestHeaders & NamespacesWriteNamespacesApiLockUnlockPathRequestBodies['application/json'];
interface NamespacesWriteNamespacesApiLockUnlockPathOperation<STATUS extends keyof NamespacesWriteNamespacesApiLockUnlockPathResponseBodies, CONTENT_TYPE extends keyof NamespacesWriteNamespacesApiLockUnlockPathParameterBodies> extends KeqOperation {
  requestParams: NamespacesWriteNamespacesApiLockUnlockPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesWriteNamespacesApiLockUnlockPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesWriteNamespacesApiLockUnlockPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: NamespacesWriteNamespacesApiLockUnlockPathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: NamespacesWriteNamespacesApiLockUnlockPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-read-namespaces-path-response.schema.d.ts
interface NamespacesReadNamespacesPathResponse {
  /**
   * User provided key-value pairs.
   * @format map
   */
  custom_metadata?: Record<string, never>;
  /**
   * Accessor ID of the namespace.
   */
  id?: string;
  /**
   * Flag representing the lock status of the namespace.
   */
  locked?: boolean;
  /**
   * Path of the namespace.
   */
  path?: string;
  /**
   * Flag representing the taint status of the namespace.
   */
  tainted?: boolean;
  /**
   * Internal UUID of the namespace.
   */
  uuid?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-read-namespaces-path.type.d.ts
interface NamespacesReadNamespacesPathResponseBodies {
  200: NamespacesReadNamespacesPathResponse;
}
type NamespacesReadNamespacesPathRequestQuery = {};
type NamespacesReadNamespacesPathRouteParameters = {};
type NamespacesReadNamespacesPathRequestHeaders = {};
type NamespacesReadNamespacesPathRequestParameters = NamespacesReadNamespacesPathRequestQuery & NamespacesReadNamespacesPathRouteParameters & NamespacesReadNamespacesPathRequestHeaders;
interface NamespacesReadNamespacesPathOperation<STATUS extends keyof NamespacesReadNamespacesPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: NamespacesReadNamespacesPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesReadNamespacesPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesReadNamespacesPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: NamespacesReadNamespacesPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-path-request.schema.d.ts
interface NamespacesWriteNamespacesPathRequest {
  /**
   * User provided key-value pairs.
   * @format map
   */
  custom_metadata?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-write-namespaces-path-response.schema.d.ts
interface NamespacesWriteNamespacesPathResponse {
  /**
   * User provided key-value pairs.
   * @format map
   */
  custom_metadata?: Record<string, never>;
  /**
   * Accessor ID of the namespace.
   */
  id?: string;
  /**
   * Flag representing the lock status of the namespace.
   */
  locked?: boolean;
  /**
   * Path of the namespace.
   */
  path?: string;
  /**
   * Flag representing the taint status of the namespace.
   */
  tainted?: boolean;
  /**
   * Internal UUID of the namespace.
   */
  uuid?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-write-namespaces-path.type.d.ts
interface NamespacesWriteNamespacesPathResponseBodies {
  200: NamespacesWriteNamespacesPathResponse;
}
interface NamespacesWriteNamespacesPathRequestBodies {
  'application/json': NamespacesWriteNamespacesPathRequest;
}
type NamespacesWriteNamespacesPathRequestQuery = {};
type NamespacesWriteNamespacesPathRouteParameters = {};
type NamespacesWriteNamespacesPathRequestHeaders = {};
interface NamespacesWriteNamespacesPathParameterBodies {
  'application/json': NamespacesWriteNamespacesPathRequest & {
    [key: string]: any;
  };
}
type NamespacesWriteNamespacesPathRequestParameters = NamespacesWriteNamespacesPathRequestQuery & NamespacesWriteNamespacesPathRouteParameters & NamespacesWriteNamespacesPathRequestHeaders & NamespacesWriteNamespacesPathRequestBodies['application/json'];
interface NamespacesWriteNamespacesPathOperation<STATUS extends keyof NamespacesWriteNamespacesPathResponseBodies, CONTENT_TYPE extends keyof NamespacesWriteNamespacesPathParameterBodies> extends KeqOperation {
  requestParams: NamespacesWriteNamespacesPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesWriteNamespacesPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesWriteNamespacesPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: NamespacesWriteNamespacesPathParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: NamespacesWriteNamespacesPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/namespaces-delete-namespaces-path-response.schema.d.ts
interface NamespacesDeleteNamespacesPathResponse {
  /**
   * Status of the deletion operation.
   */
  status?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/namespaces-delete-namespaces-path.type.d.ts
interface NamespacesDeleteNamespacesPathResponseBodies {
  200: NamespacesDeleteNamespacesPathResponse;
  204: void;
}
type NamespacesDeleteNamespacesPathRequestQuery = {};
type NamespacesDeleteNamespacesPathRouteParameters = {};
type NamespacesDeleteNamespacesPathRequestHeaders = {};
type NamespacesDeleteNamespacesPathRequestParameters = NamespacesDeleteNamespacesPathRequestQuery & NamespacesDeleteNamespacesPathRouteParameters & NamespacesDeleteNamespacesPathRequestHeaders;
interface NamespacesDeleteNamespacesPathOperation<STATUS extends keyof NamespacesDeleteNamespacesPathResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: NamespacesDeleteNamespacesPathRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: NamespacesDeleteNamespacesPathRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: NamespacesDeleteNamespacesPathRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: NamespacesDeleteNamespacesPathResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-list-plugins-response.schema.d.ts
interface PluginsCatalogListPluginsResponse {
  /**
   * @format map
   */
  detailed?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-list-plugins.type.d.ts
interface PluginsCatalogListPluginsResponseBodies {
  200: PluginsCatalogListPluginsResponse;
}
type PluginsCatalogListPluginsRequestQuery = {};
type PluginsCatalogListPluginsRouteParameters = {};
type PluginsCatalogListPluginsRequestHeaders = {};
type PluginsCatalogListPluginsRequestParameters = PluginsCatalogListPluginsRequestQuery & PluginsCatalogListPluginsRouteParameters & PluginsCatalogListPluginsRequestHeaders;
interface PluginsCatalogListPluginsOperation<STATUS extends keyof PluginsCatalogListPluginsResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogListPluginsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogListPluginsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogListPluginsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogListPluginsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-read-plugin-configuration-response.schema.d.ts
interface PluginsCatalogReadPluginConfigurationResponse {
  /**
   * The args passed to plugin command.
   */
  args?: string[];
  builtin?: boolean;
  /**
   * The command used to start the plugin. The executable defined in this command must exist in OpenBao's plugin directory.
   */
  command?: string;
  declarative?: boolean;
  deprecation_status?: string;
  /**
   * The name of the plugin
   */
  name?: string;
  oci?: boolean;
  /**
   * The SHA256 sum of the executable used in the command field. This should be HEX encoded.
   */
  sha256?: string;
  /**
   * The semantic version of the plugin to use.
   */
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-read-plugin-configuration.type.d.ts
interface PluginsCatalogReadPluginConfigurationResponseBodies {
  200: PluginsCatalogReadPluginConfigurationResponse;
}
type PluginsCatalogReadPluginConfigurationRequestQuery = {};
type PluginsCatalogReadPluginConfigurationRouteParameters = {};
type PluginsCatalogReadPluginConfigurationRequestHeaders = {};
type PluginsCatalogReadPluginConfigurationRequestParameters = PluginsCatalogReadPluginConfigurationRequestQuery & PluginsCatalogReadPluginConfigurationRouteParameters & PluginsCatalogReadPluginConfigurationRequestHeaders;
interface PluginsCatalogReadPluginConfigurationOperation<STATUS extends keyof PluginsCatalogReadPluginConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogReadPluginConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogReadPluginConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogReadPluginConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogReadPluginConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-register-plugin-request.schema.d.ts
interface PluginsCatalogRegisterPluginRequest {
  /**
   * The args passed to plugin command.
   */
  args?: string[];
  /**
   * The command used to start the plugin. The executable defined in this command must exist in OpenBao's plugin directory.
   */
  command?: string;
  /**
   * The environment variables passed to plugin command. Each entry is of the form "key=value".
   */
  env?: string[];
  oci?: boolean;
  /**
   * The SHA256 sum of the executable used in the command field. This should be HEX encoded.
   */
  sha256?: string;
  /**
   * The type of the plugin, may be auth, secret, or database
   */
  type?: string;
  /**
   * The semantic version of the plugin to use.
   */
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-register-plugin.type.d.ts
interface PluginsCatalogRegisterPluginResponseBodies {
  200: void;
}
interface PluginsCatalogRegisterPluginRequestBodies {
  'application/json': PluginsCatalogRegisterPluginRequest;
}
type PluginsCatalogRegisterPluginRequestQuery = {};
type PluginsCatalogRegisterPluginRouteParameters = {};
type PluginsCatalogRegisterPluginRequestHeaders = {};
interface PluginsCatalogRegisterPluginParameterBodies {
  'application/json': PluginsCatalogRegisterPluginRequest & {
    [key: string]: any;
  };
}
type PluginsCatalogRegisterPluginRequestParameters = PluginsCatalogRegisterPluginRequestQuery & PluginsCatalogRegisterPluginRouteParameters & PluginsCatalogRegisterPluginRequestHeaders & PluginsCatalogRegisterPluginRequestBodies['application/json'];
interface PluginsCatalogRegisterPluginOperation<STATUS extends keyof PluginsCatalogRegisterPluginResponseBodies, CONTENT_TYPE extends keyof PluginsCatalogRegisterPluginParameterBodies> extends KeqOperation {
  requestParams: PluginsCatalogRegisterPluginRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogRegisterPluginRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogRegisterPluginRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PluginsCatalogRegisterPluginParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PluginsCatalogRegisterPluginResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-remove-plugin.type.d.ts
interface PluginsCatalogRemovePluginResponseBodies {
  200: void;
}
type PluginsCatalogRemovePluginRequestQuery = {};
type PluginsCatalogRemovePluginRouteParameters = {};
type PluginsCatalogRemovePluginRequestHeaders = {};
type PluginsCatalogRemovePluginRequestParameters = PluginsCatalogRemovePluginRequestQuery & PluginsCatalogRemovePluginRouteParameters & PluginsCatalogRemovePluginRequestHeaders;
interface PluginsCatalogRemovePluginOperation<STATUS extends keyof PluginsCatalogRemovePluginResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogRemovePluginRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogRemovePluginRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogRemovePluginRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogRemovePluginResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-list-plugins-with-type-response.schema.d.ts
interface PluginsCatalogListPluginsWithTypeResponse {
  /**
   * List of plugin names in the catalog
   */
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-list-plugins-with-type.type.d.ts
interface PluginsCatalogListPluginsWithTypeResponseBodies {
  200: PluginsCatalogListPluginsWithTypeResponse;
}
type PluginsCatalogListPluginsWithTypeRequestQuery = {
  list: ('true');
};
type PluginsCatalogListPluginsWithTypeRouteParameters = {};
type PluginsCatalogListPluginsWithTypeRequestHeaders = {};
type PluginsCatalogListPluginsWithTypeRequestParameters = PluginsCatalogListPluginsWithTypeRequestQuery & PluginsCatalogListPluginsWithTypeRouteParameters & PluginsCatalogListPluginsWithTypeRequestHeaders;
interface PluginsCatalogListPluginsWithTypeOperation<STATUS extends keyof PluginsCatalogListPluginsWithTypeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogListPluginsWithTypeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogListPluginsWithTypeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogListPluginsWithTypeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogListPluginsWithTypeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-read-plugin-configuration-with-type-response.schema.d.ts
interface PluginsCatalogReadPluginConfigurationWithTypeResponse {
  /**
   * The args passed to plugin command.
   */
  args?: string[];
  builtin?: boolean;
  /**
   * The command used to start the plugin. The executable defined in this command must exist in OpenBao's plugin directory.
   */
  command?: string;
  declarative?: boolean;
  deprecation_status?: string;
  /**
   * The name of the plugin
   */
  name?: string;
  oci?: boolean;
  /**
   * The SHA256 sum of the executable used in the command field. This should be HEX encoded.
   */
  sha256?: string;
  /**
   * The semantic version of the plugin to use.
   */
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-read-plugin-configuration-with-type.type.d.ts
interface PluginsCatalogReadPluginConfigurationWithTypeResponseBodies {
  200: PluginsCatalogReadPluginConfigurationWithTypeResponse;
}
type PluginsCatalogReadPluginConfigurationWithTypeRequestQuery = {};
type PluginsCatalogReadPluginConfigurationWithTypeRouteParameters = {};
type PluginsCatalogReadPluginConfigurationWithTypeRequestHeaders = {};
type PluginsCatalogReadPluginConfigurationWithTypeRequestParameters = PluginsCatalogReadPluginConfigurationWithTypeRequestQuery & PluginsCatalogReadPluginConfigurationWithTypeRouteParameters & PluginsCatalogReadPluginConfigurationWithTypeRequestHeaders;
interface PluginsCatalogReadPluginConfigurationWithTypeOperation<STATUS extends keyof PluginsCatalogReadPluginConfigurationWithTypeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogReadPluginConfigurationWithTypeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogReadPluginConfigurationWithTypeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogReadPluginConfigurationWithTypeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogReadPluginConfigurationWithTypeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-catalog-register-plugin-with-type-request.schema.d.ts
interface PluginsCatalogRegisterPluginWithTypeRequest {
  /**
   * The args passed to plugin command.
   */
  args?: string[];
  /**
   * The command used to start the plugin. The executable defined in this command must exist in OpenBao's plugin directory.
   */
  command?: string;
  /**
   * The environment variables passed to plugin command. Each entry is of the form "key=value".
   */
  env?: string[];
  oci?: boolean;
  /**
   * The SHA256 sum of the executable used in the command field. This should be HEX encoded.
   */
  sha256?: string;
  /**
   * The semantic version of the plugin to use.
   */
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-register-plugin-with-type.type.d.ts
interface PluginsCatalogRegisterPluginWithTypeResponseBodies {
  200: void;
}
interface PluginsCatalogRegisterPluginWithTypeRequestBodies {
  'application/json': PluginsCatalogRegisterPluginWithTypeRequest;
}
type PluginsCatalogRegisterPluginWithTypeRequestQuery = {};
type PluginsCatalogRegisterPluginWithTypeRouteParameters = {};
type PluginsCatalogRegisterPluginWithTypeRequestHeaders = {};
interface PluginsCatalogRegisterPluginWithTypeParameterBodies {
  'application/json': PluginsCatalogRegisterPluginWithTypeRequest & {
    [key: string]: any;
  };
}
type PluginsCatalogRegisterPluginWithTypeRequestParameters = PluginsCatalogRegisterPluginWithTypeRequestQuery & PluginsCatalogRegisterPluginWithTypeRouteParameters & PluginsCatalogRegisterPluginWithTypeRequestHeaders & PluginsCatalogRegisterPluginWithTypeRequestBodies['application/json'];
interface PluginsCatalogRegisterPluginWithTypeOperation<STATUS extends keyof PluginsCatalogRegisterPluginWithTypeResponseBodies, CONTENT_TYPE extends keyof PluginsCatalogRegisterPluginWithTypeParameterBodies> extends KeqOperation {
  requestParams: PluginsCatalogRegisterPluginWithTypeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogRegisterPluginWithTypeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogRegisterPluginWithTypeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PluginsCatalogRegisterPluginWithTypeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PluginsCatalogRegisterPluginWithTypeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-catalog-remove-plugin-with-type.type.d.ts
interface PluginsCatalogRemovePluginWithTypeResponseBodies {
  200: void;
}
type PluginsCatalogRemovePluginWithTypeRequestQuery = {};
type PluginsCatalogRemovePluginWithTypeRouteParameters = {};
type PluginsCatalogRemovePluginWithTypeRequestHeaders = {};
type PluginsCatalogRemovePluginWithTypeRequestParameters = PluginsCatalogRemovePluginWithTypeRequestQuery & PluginsCatalogRemovePluginWithTypeRouteParameters & PluginsCatalogRemovePluginWithTypeRequestHeaders;
interface PluginsCatalogRemovePluginWithTypeOperation<STATUS extends keyof PluginsCatalogRemovePluginWithTypeResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PluginsCatalogRemovePluginWithTypeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsCatalogRemovePluginWithTypeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsCatalogRemovePluginWithTypeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PluginsCatalogRemovePluginWithTypeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-reload-backends-request.schema.d.ts
interface PluginsReloadBackendsRequest {
  /**
   * The mount paths of the plugin backends to reload.
   */
  mounts?: string[];
  /**
   * The name of the plugin to reload, as registered in the plugin catalog.
   */
  plugin?: string;
  scope?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/plugins-reload-backends-response.schema.d.ts
interface PluginsReloadBackendsResponse {
  reload_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/plugins-reload-backends.type.d.ts
interface PluginsReloadBackendsResponseBodies {
  200: PluginsReloadBackendsResponse;
  202: PluginsReloadBackendsResponse;
}
interface PluginsReloadBackendsRequestBodies {
  'application/json': PluginsReloadBackendsRequest;
}
type PluginsReloadBackendsRequestQuery = {};
type PluginsReloadBackendsRouteParameters = {};
type PluginsReloadBackendsRequestHeaders = {};
interface PluginsReloadBackendsParameterBodies {
  'application/json': PluginsReloadBackendsRequest & {
    [key: string]: any;
  };
}
type PluginsReloadBackendsRequestParameters = PluginsReloadBackendsRequestQuery & PluginsReloadBackendsRouteParameters & PluginsReloadBackendsRequestHeaders & PluginsReloadBackendsRequestBodies['application/json'];
interface PluginsReloadBackendsOperation<STATUS extends keyof PluginsReloadBackendsResponseBodies, CONTENT_TYPE extends keyof PluginsReloadBackendsParameterBodies> extends KeqOperation {
  requestParams: PluginsReloadBackendsRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PluginsReloadBackendsRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PluginsReloadBackendsRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PluginsReloadBackendsParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PluginsReloadBackendsResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-list-acl-policies-response.schema.d.ts
interface PoliciesListAclPoliciesResponse {
  keys?: string[];
  policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-list-acl-policies.type.d.ts
interface PoliciesListAclPoliciesResponseBodies {
  200: PoliciesListAclPoliciesResponse;
}
type PoliciesListAclPoliciesRequestQuery = {
  list: ('true');
};
type PoliciesListAclPoliciesRouteParameters = {};
type PoliciesListAclPoliciesRequestHeaders = {};
type PoliciesListAclPoliciesRequestParameters = PoliciesListAclPoliciesRequestQuery & PoliciesListAclPoliciesRouteParameters & PoliciesListAclPoliciesRequestHeaders;
interface PoliciesListAclPoliciesOperation<STATUS extends keyof PoliciesListAclPoliciesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesListAclPoliciesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesListAclPoliciesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesListAclPoliciesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesListAclPoliciesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-read-acl-policy-response.schema.d.ts
interface PoliciesReadAclPolicyResponse {
  cas_required?: boolean;
  /**
   * @format date-time
   */
  expiration?: string;
  /**
   * @format date-time
   */
  modified?: string;
  name?: string;
  policy?: string;
  rules?: string;
  version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-read-acl-policy.type.d.ts
interface PoliciesReadAclPolicyResponseBodies {
  200: PoliciesReadAclPolicyResponse;
}
type PoliciesReadAclPolicyRequestQuery = {
  list?: string;
};
type PoliciesReadAclPolicyRouteParameters = {};
type PoliciesReadAclPolicyRequestHeaders = {};
type PoliciesReadAclPolicyRequestParameters = PoliciesReadAclPolicyRequestQuery & PoliciesReadAclPolicyRouteParameters & PoliciesReadAclPolicyRequestHeaders;
interface PoliciesReadAclPolicyOperation<STATUS extends keyof PoliciesReadAclPolicyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesReadAclPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesReadAclPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesReadAclPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesReadAclPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-write-acl-policy-request.schema.d.ts
interface PoliciesWriteAclPolicyRequest {
  /**
   * The rules of the policy.
   */
  cas?: number;
  /**
   * The rules of the policy.
   */
  cas_required?: boolean;
  /**
   * The rules of the policy.
   * @format date-time
   */
  expiration?: string;
  /**
   * The rules of the policy.
   */
  policy?: string;
  /**
   * The rules of the policy.
   * @format seconds
   */
  ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-write-acl-policy.type.d.ts
interface PoliciesWriteAclPolicyResponseBodies {
  204: void;
}
interface PoliciesWriteAclPolicyRequestBodies {
  'application/json': PoliciesWriteAclPolicyRequest;
}
type PoliciesWriteAclPolicyRequestQuery = {};
type PoliciesWriteAclPolicyRouteParameters = {};
type PoliciesWriteAclPolicyRequestHeaders = {};
interface PoliciesWriteAclPolicyParameterBodies {
  'application/json': PoliciesWriteAclPolicyRequest & {
    [key: string]: any;
  };
}
type PoliciesWriteAclPolicyRequestParameters = PoliciesWriteAclPolicyRequestQuery & PoliciesWriteAclPolicyRouteParameters & PoliciesWriteAclPolicyRequestHeaders & PoliciesWriteAclPolicyRequestBodies['application/json'];
interface PoliciesWriteAclPolicyOperation<STATUS extends keyof PoliciesWriteAclPolicyResponseBodies, CONTENT_TYPE extends keyof PoliciesWriteAclPolicyParameterBodies> extends KeqOperation {
  requestParams: PoliciesWriteAclPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesWriteAclPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesWriteAclPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PoliciesWriteAclPolicyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PoliciesWriteAclPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-delete-acl-policy.type.d.ts
interface PoliciesDeleteAclPolicyResponseBodies {
  204: void;
}
type PoliciesDeleteAclPolicyRequestQuery = {};
type PoliciesDeleteAclPolicyRouteParameters = {};
type PoliciesDeleteAclPolicyRequestHeaders = {};
type PoliciesDeleteAclPolicyRequestParameters = PoliciesDeleteAclPolicyRequestQuery & PoliciesDeleteAclPolicyRouteParameters & PoliciesDeleteAclPolicyRequestHeaders;
interface PoliciesDeleteAclPolicyOperation<STATUS extends keyof PoliciesDeleteAclPolicyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesDeleteAclPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesDeleteAclPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesDeleteAclPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesDeleteAclPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/system-list-policies-detailed-acl.type.d.ts
interface SystemListPoliciesDetailedAclResponseBodies {
  200: void;
}
type SystemListPoliciesDetailedAclRequestQuery = {
  list: ('true');
};
type SystemListPoliciesDetailedAclRouteParameters = {};
type SystemListPoliciesDetailedAclRequestHeaders = {};
type SystemListPoliciesDetailedAclRequestParameters = SystemListPoliciesDetailedAclRequestQuery & SystemListPoliciesDetailedAclRouteParameters & SystemListPoliciesDetailedAclRequestHeaders;
interface SystemListPoliciesDetailedAclOperation<STATUS extends keyof SystemListPoliciesDetailedAclResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: SystemListPoliciesDetailedAclRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: SystemListPoliciesDetailedAclRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: SystemListPoliciesDetailedAclRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: SystemListPoliciesDetailedAclResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/system-list-policies-detailed-acl-name.type.d.ts
interface SystemListPoliciesDetailedAclNameResponseBodies {
  200: void;
}
type SystemListPoliciesDetailedAclNameRequestQuery = {
  list: ('true');
};
type SystemListPoliciesDetailedAclNameRouteParameters = {};
type SystemListPoliciesDetailedAclNameRequestHeaders = {};
type SystemListPoliciesDetailedAclNameRequestParameters = SystemListPoliciesDetailedAclNameRequestQuery & SystemListPoliciesDetailedAclNameRouteParameters & SystemListPoliciesDetailedAclNameRequestHeaders;
interface SystemListPoliciesDetailedAclNameOperation<STATUS extends keyof SystemListPoliciesDetailedAclNameResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: SystemListPoliciesDetailedAclNameRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: SystemListPoliciesDetailedAclNameRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: SystemListPoliciesDetailedAclNameRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: SystemListPoliciesDetailedAclNameResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-list-password-policies-response.schema.d.ts
interface PoliciesListPasswordPoliciesResponse {
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-list-password-policies.type.d.ts
interface PoliciesListPasswordPoliciesResponseBodies {
  200: PoliciesListPasswordPoliciesResponse;
}
type PoliciesListPasswordPoliciesRequestQuery = {
  list: ('true');
};
type PoliciesListPasswordPoliciesRouteParameters = {};
type PoliciesListPasswordPoliciesRequestHeaders = {};
type PoliciesListPasswordPoliciesRequestParameters = PoliciesListPasswordPoliciesRequestQuery & PoliciesListPasswordPoliciesRouteParameters & PoliciesListPasswordPoliciesRequestHeaders;
interface PoliciesListPasswordPoliciesOperation<STATUS extends keyof PoliciesListPasswordPoliciesResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesListPasswordPoliciesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesListPasswordPoliciesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesListPasswordPoliciesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesListPasswordPoliciesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-read-password-policy-response.schema.d.ts
interface PoliciesReadPasswordPolicyResponse {
  policy?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-read-password-policy.type.d.ts
interface PoliciesReadPasswordPolicyResponseBodies {
  204: PoliciesReadPasswordPolicyResponse;
}
type PoliciesReadPasswordPolicyRequestQuery = {};
type PoliciesReadPasswordPolicyRouteParameters = {};
type PoliciesReadPasswordPolicyRequestHeaders = {};
type PoliciesReadPasswordPolicyRequestParameters = PoliciesReadPasswordPolicyRequestQuery & PoliciesReadPasswordPolicyRouteParameters & PoliciesReadPasswordPolicyRequestHeaders;
interface PoliciesReadPasswordPolicyOperation<STATUS extends keyof PoliciesReadPasswordPolicyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesReadPasswordPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesReadPasswordPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesReadPasswordPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesReadPasswordPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-write-password-policy-request.schema.d.ts
interface PoliciesWritePasswordPolicyRequest {
  /**
   * The password policy
   */
  policy?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-write-password-policy.type.d.ts
interface PoliciesWritePasswordPolicyResponseBodies {
  204: void;
}
interface PoliciesWritePasswordPolicyRequestBodies {
  'application/json': PoliciesWritePasswordPolicyRequest;
}
type PoliciesWritePasswordPolicyRequestQuery = {};
type PoliciesWritePasswordPolicyRouteParameters = {};
type PoliciesWritePasswordPolicyRequestHeaders = {};
interface PoliciesWritePasswordPolicyParameterBodies {
  'application/json': PoliciesWritePasswordPolicyRequest & {
    [key: string]: any;
  };
}
type PoliciesWritePasswordPolicyRequestParameters = PoliciesWritePasswordPolicyRequestQuery & PoliciesWritePasswordPolicyRouteParameters & PoliciesWritePasswordPolicyRequestHeaders & PoliciesWritePasswordPolicyRequestBodies['application/json'];
interface PoliciesWritePasswordPolicyOperation<STATUS extends keyof PoliciesWritePasswordPolicyResponseBodies, CONTENT_TYPE extends keyof PoliciesWritePasswordPolicyParameterBodies> extends KeqOperation {
  requestParams: PoliciesWritePasswordPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesWritePasswordPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesWritePasswordPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: PoliciesWritePasswordPolicyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: PoliciesWritePasswordPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-delete-password-policy.type.d.ts
interface PoliciesDeletePasswordPolicyResponseBodies {
  204: void;
}
type PoliciesDeletePasswordPolicyRequestQuery = {};
type PoliciesDeletePasswordPolicyRouteParameters = {};
type PoliciesDeletePasswordPolicyRequestHeaders = {};
type PoliciesDeletePasswordPolicyRequestParameters = PoliciesDeletePasswordPolicyRequestQuery & PoliciesDeletePasswordPolicyRouteParameters & PoliciesDeletePasswordPolicyRequestHeaders;
interface PoliciesDeletePasswordPolicyOperation<STATUS extends keyof PoliciesDeletePasswordPolicyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesDeletePasswordPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesDeletePasswordPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesDeletePasswordPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesDeletePasswordPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-generate-password-from-password-policy-response.schema.d.ts
interface PoliciesGeneratePasswordFromPasswordPolicyResponse {
  password?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-generate-password-from-password-policy.type.d.ts
interface PoliciesGeneratePasswordFromPasswordPolicyResponseBodies {
  200: PoliciesGeneratePasswordFromPasswordPolicyResponse;
}
type PoliciesGeneratePasswordFromPasswordPolicyRequestQuery = {};
type PoliciesGeneratePasswordFromPasswordPolicyRouteParameters = {};
type PoliciesGeneratePasswordFromPasswordPolicyRequestHeaders = {};
type PoliciesGeneratePasswordFromPasswordPolicyRequestParameters = PoliciesGeneratePasswordFromPasswordPolicyRequestQuery & PoliciesGeneratePasswordFromPasswordPolicyRouteParameters & PoliciesGeneratePasswordFromPasswordPolicyRequestHeaders;
interface PoliciesGeneratePasswordFromPasswordPolicyOperation<STATUS extends keyof PoliciesGeneratePasswordFromPasswordPolicyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesGeneratePasswordFromPasswordPolicyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesGeneratePasswordFromPasswordPolicyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesGeneratePasswordFromPasswordPolicyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesGeneratePasswordFromPasswordPolicyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/policies-list-response.schema.d.ts
interface PoliciesListResponse {
  keys?: string[];
  policies?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/policies-list.type.d.ts
interface PoliciesListResponseBodies {
  200: PoliciesListResponse;
}
type PoliciesListRequestQuery = {
  list?: string;
};
type PoliciesListRouteParameters = {};
type PoliciesListRequestHeaders = {};
type PoliciesListRequestParameters = PoliciesListRequestQuery & PoliciesListRouteParameters & PoliciesListRequestHeaders;
interface PoliciesListOperation<STATUS extends keyof PoliciesListResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: PoliciesListRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: PoliciesListRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: PoliciesListRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: PoliciesListResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rate-limit-quotas-read-configuration-response.schema.d.ts
interface RateLimitQuotasReadConfigurationResponse {
  enable_rate_limit_audit_logging?: boolean;
  enable_rate_limit_response_headers?: boolean;
  rate_limit_exempt_paths?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-read-configuration.type.d.ts
interface RateLimitQuotasReadConfigurationResponseBodies {
  200: RateLimitQuotasReadConfigurationResponse;
}
type RateLimitQuotasReadConfigurationRequestQuery = {};
type RateLimitQuotasReadConfigurationRouteParameters = {};
type RateLimitQuotasReadConfigurationRequestHeaders = {};
type RateLimitQuotasReadConfigurationRequestParameters = RateLimitQuotasReadConfigurationRequestQuery & RateLimitQuotasReadConfigurationRouteParameters & RateLimitQuotasReadConfigurationRequestHeaders;
interface RateLimitQuotasReadConfigurationOperation<STATUS extends keyof RateLimitQuotasReadConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RateLimitQuotasReadConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasReadConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasReadConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RateLimitQuotasReadConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rate-limit-quotas-configure-request.schema.d.ts
interface RateLimitQuotasConfigureRequest {
  /**
   * If set, starts audit logging of requests that get rejected due to rate limit quota rule violations.
   */
  enable_rate_limit_audit_logging?: boolean;
  /**
   * If set, additional rate limit quota HTTP headers will be added to responses.
   */
  enable_rate_limit_response_headers?: boolean;
  /**
   * Specifies the list of exempt paths from all rate limit quotas. If empty no paths will be exempt.
   */
  rate_limit_exempt_paths?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-configure.type.d.ts
interface RateLimitQuotasConfigureResponseBodies {
  204: void;
}
interface RateLimitQuotasConfigureRequestBodies {
  'application/json': RateLimitQuotasConfigureRequest;
}
type RateLimitQuotasConfigureRequestQuery = {};
type RateLimitQuotasConfigureRouteParameters = {};
type RateLimitQuotasConfigureRequestHeaders = {};
interface RateLimitQuotasConfigureParameterBodies {
  'application/json': RateLimitQuotasConfigureRequest & {
    [key: string]: any;
  };
}
type RateLimitQuotasConfigureRequestParameters = RateLimitQuotasConfigureRequestQuery & RateLimitQuotasConfigureRouteParameters & RateLimitQuotasConfigureRequestHeaders & RateLimitQuotasConfigureRequestBodies['application/json'];
interface RateLimitQuotasConfigureOperation<STATUS extends keyof RateLimitQuotasConfigureResponseBodies, CONTENT_TYPE extends keyof RateLimitQuotasConfigureParameterBodies> extends KeqOperation {
  requestParams: RateLimitQuotasConfigureRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasConfigureRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasConfigureRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RateLimitQuotasConfigureParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RateLimitQuotasConfigureResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rate-limit-quotas-list-response.schema.d.ts
interface RateLimitQuotasListResponse {
  keys?: string[];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-list.type.d.ts
interface RateLimitQuotasListResponseBodies {
  200: RateLimitQuotasListResponse;
}
type RateLimitQuotasListRequestQuery = {
  list: ('true');
};
type RateLimitQuotasListRouteParameters = {};
type RateLimitQuotasListRequestHeaders = {};
type RateLimitQuotasListRequestParameters = RateLimitQuotasListRequestQuery & RateLimitQuotasListRouteParameters & RateLimitQuotasListRequestHeaders;
interface RateLimitQuotasListOperation<STATUS extends keyof RateLimitQuotasListResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RateLimitQuotasListRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasListRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasListRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RateLimitQuotasListResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rate-limit-quotas-read-response.schema.d.ts
interface RateLimitQuotasReadResponse {
  block_interval?: number;
  inheritable?: boolean;
  interval?: number;
  name?: string;
  path?: string;
  /**
   * @format float
   */
  rate?: number;
  role?: string;
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-read.type.d.ts
interface RateLimitQuotasReadResponseBodies {
  200: RateLimitQuotasReadResponse;
}
type RateLimitQuotasReadRequestQuery = {};
type RateLimitQuotasReadRouteParameters = {};
type RateLimitQuotasReadRequestHeaders = {};
type RateLimitQuotasReadRequestParameters = RateLimitQuotasReadRequestQuery & RateLimitQuotasReadRouteParameters & RateLimitQuotasReadRequestHeaders;
interface RateLimitQuotasReadOperation<STATUS extends keyof RateLimitQuotasReadResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RateLimitQuotasReadRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasReadRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasReadRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RateLimitQuotasReadResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rate-limit-quotas-write-request.schema.d.ts
interface RateLimitQuotasWriteRequest {
  /**
   * If set, when a client reaches a rate limit threshold, the client will be prohibited from any further requests until after the 'block_interval' has elapsed.
   * @format seconds
   */
  block_interval?: number;
  /**
   * If set to true, child namespaces will use this quota, unless another more specific quota exists. Can only be set on namespace quotas. A quota on the root namespace will by default be inheritable.
   */
  inheritable?: boolean;
  /**
   * The duration to enforce rate limiting for (default '1s').
   * @format seconds
   */
  interval?: number;
  /**
   * Path of the mount or namespace to apply the quota. A blank path configures a global quota. For example namespace1/ adds a quota to a full namespace, namespace1/auth/userpass adds a quota to userpass in namespace1.
   */
  path?: string;
  /**
   * The maximum number of requests in a given interval to be allowed by the quota rule. The 'rate' must be positive.
   * @format float
   */
  rate?: number;
  /**
   * Login role to apply this quota to. Note that when set, path must be configured to a valid auth method with a concept of roles.
   */
  role?: string;
  /**
   * Type of the quota rule.
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-write.type.d.ts
interface RateLimitQuotasWriteResponseBodies {
  204: void;
}
interface RateLimitQuotasWriteRequestBodies {
  'application/json': RateLimitQuotasWriteRequest;
}
type RateLimitQuotasWriteRequestQuery = {};
type RateLimitQuotasWriteRouteParameters = {};
type RateLimitQuotasWriteRequestHeaders = {};
interface RateLimitQuotasWriteParameterBodies {
  'application/json': RateLimitQuotasWriteRequest & {
    [key: string]: any;
  };
}
type RateLimitQuotasWriteRequestParameters = RateLimitQuotasWriteRequestQuery & RateLimitQuotasWriteRouteParameters & RateLimitQuotasWriteRequestHeaders & RateLimitQuotasWriteRequestBodies['application/json'];
interface RateLimitQuotasWriteOperation<STATUS extends keyof RateLimitQuotasWriteResponseBodies, CONTENT_TYPE extends keyof RateLimitQuotasWriteParameterBodies> extends KeqOperation {
  requestParams: RateLimitQuotasWriteRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasWriteRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasWriteRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RateLimitQuotasWriteParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RateLimitQuotasWriteResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rate-limit-quotas-delete.type.d.ts
interface RateLimitQuotasDeleteResponseBodies {
  204: void;
}
type RateLimitQuotasDeleteRequestQuery = {};
type RateLimitQuotasDeleteRouteParameters = {};
type RateLimitQuotasDeleteRequestHeaders = {};
type RateLimitQuotasDeleteRequestParameters = RateLimitQuotasDeleteRequestQuery & RateLimitQuotasDeleteRouteParameters & RateLimitQuotasDeleteRequestHeaders;
interface RateLimitQuotasDeleteOperation<STATUS extends keyof RateLimitQuotasDeleteResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RateLimitQuotasDeleteRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RateLimitQuotasDeleteRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RateLimitQuotasDeleteRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RateLimitQuotasDeleteResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-read-backup-key-response.schema.d.ts
interface RekeyReadBackupKeyResponse {
  /**
   * @format map
   */
  keys?: Record<string, never>;
  /**
   * @format map
   */
  keys_base64?: Record<string, never>;
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-read-backup-key.type.d.ts
interface RekeyReadBackupKeyResponseBodies {
  200: RekeyReadBackupKeyResponse;
}
type RekeyReadBackupKeyRequestQuery = {};
type RekeyReadBackupKeyRouteParameters = {};
type RekeyReadBackupKeyRequestHeaders = {};
type RekeyReadBackupKeyRequestParameters = RekeyReadBackupKeyRequestQuery & RekeyReadBackupKeyRouteParameters & RekeyReadBackupKeyRequestHeaders;
interface RekeyReadBackupKeyOperation<STATUS extends keyof RekeyReadBackupKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyReadBackupKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyReadBackupKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyReadBackupKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyReadBackupKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-delete-backup-key.type.d.ts
interface RekeyDeleteBackupKeyResponseBodies {
  204: void;
}
type RekeyDeleteBackupKeyRequestQuery = {};
type RekeyDeleteBackupKeyRouteParameters = {};
type RekeyDeleteBackupKeyRequestHeaders = {};
type RekeyDeleteBackupKeyRequestParameters = RekeyDeleteBackupKeyRequestQuery & RekeyDeleteBackupKeyRouteParameters & RekeyDeleteBackupKeyRequestHeaders;
interface RekeyDeleteBackupKeyOperation<STATUS extends keyof RekeyDeleteBackupKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyDeleteBackupKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyDeleteBackupKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyDeleteBackupKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyDeleteBackupKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-attempt-read-progress-response.schema.d.ts
interface RekeyAttemptReadProgressResponse {
  backup?: boolean;
  n?: number;
  nounce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: string;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-attempt-read-progress.type.d.ts
interface RekeyAttemptReadProgressResponseBodies {
  200: RekeyAttemptReadProgressResponse;
}
type RekeyAttemptReadProgressRequestQuery = {};
type RekeyAttemptReadProgressRouteParameters = {};
type RekeyAttemptReadProgressRequestHeaders = {};
type RekeyAttemptReadProgressRequestParameters = RekeyAttemptReadProgressRequestQuery & RekeyAttemptReadProgressRouteParameters & RekeyAttemptReadProgressRequestHeaders;
interface RekeyAttemptReadProgressOperation<STATUS extends keyof RekeyAttemptReadProgressResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyAttemptReadProgressRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyAttemptReadProgressRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyAttemptReadProgressRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyAttemptReadProgressResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-attempt-initialize-request.schema.d.ts
interface RekeyAttemptInitializeRequest {
  /**
   * Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the PGP-encrypted keys.
   */
  backup?: boolean;
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys. Ordering is preserved. The keys must be base64-encoded from their original binary representation. The size of this array must be the same as secret_shares.
   */
  pgp_keys?: string[];
  /**
   * Turns on verification functionality
   */
  require_verification?: boolean;
  /**
   * Specifies the number of shares to split the unseal key into.
   */
  secret_shares?: number;
  /**
   * Specifies the number of shares required to reconstruct the unseal key. This must be less than or equal secret_shares. If using OpenBao HSM with auto-unsealing, this value must be the same as secret_shares.
   */
  secret_threshold?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-attempt-initialize-response.schema.d.ts
interface RekeyAttemptInitializeResponse {
  backup?: boolean;
  n?: number;
  nounce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: string;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-attempt-initialize.type.d.ts
interface RekeyAttemptInitializeResponseBodies {
  200: RekeyAttemptInitializeResponse;
}
interface RekeyAttemptInitializeRequestBodies {
  'application/json': RekeyAttemptInitializeRequest;
}
type RekeyAttemptInitializeRequestQuery = {};
type RekeyAttemptInitializeRouteParameters = {};
type RekeyAttemptInitializeRequestHeaders = {};
interface RekeyAttemptInitializeParameterBodies {
  'application/json': RekeyAttemptInitializeRequest & {
    [key: string]: any;
  };
}
type RekeyAttemptInitializeRequestParameters = RekeyAttemptInitializeRequestQuery & RekeyAttemptInitializeRouteParameters & RekeyAttemptInitializeRequestHeaders & RekeyAttemptInitializeRequestBodies['application/json'];
interface RekeyAttemptInitializeOperation<STATUS extends keyof RekeyAttemptInitializeResponseBodies, CONTENT_TYPE extends keyof RekeyAttemptInitializeParameterBodies> extends KeqOperation {
  requestParams: RekeyAttemptInitializeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyAttemptInitializeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyAttemptInitializeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RekeyAttemptInitializeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RekeyAttemptInitializeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-attempt-cancel.type.d.ts
interface RekeyAttemptCancelResponseBodies {
  200: void;
}
type RekeyAttemptCancelRequestQuery = {};
type RekeyAttemptCancelRouteParameters = {};
type RekeyAttemptCancelRequestHeaders = {};
type RekeyAttemptCancelRequestParameters = RekeyAttemptCancelRequestQuery & RekeyAttemptCancelRouteParameters & RekeyAttemptCancelRequestHeaders;
interface RekeyAttemptCancelOperation<STATUS extends keyof RekeyAttemptCancelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyAttemptCancelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyAttemptCancelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyAttemptCancelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyAttemptCancelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-read-backup-recovery-key-response.schema.d.ts
interface RekeyReadBackupRecoveryKeyResponse {
  /**
   * @format map
   */
  keys?: Record<string, never>;
  /**
   * @format map
   */
  keys_base64?: Record<string, never>;
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-read-backup-recovery-key.type.d.ts
interface RekeyReadBackupRecoveryKeyResponseBodies {
  200: RekeyReadBackupRecoveryKeyResponse;
}
type RekeyReadBackupRecoveryKeyRequestQuery = {};
type RekeyReadBackupRecoveryKeyRouteParameters = {};
type RekeyReadBackupRecoveryKeyRequestHeaders = {};
type RekeyReadBackupRecoveryKeyRequestParameters = RekeyReadBackupRecoveryKeyRequestQuery & RekeyReadBackupRecoveryKeyRouteParameters & RekeyReadBackupRecoveryKeyRequestHeaders;
interface RekeyReadBackupRecoveryKeyOperation<STATUS extends keyof RekeyReadBackupRecoveryKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyReadBackupRecoveryKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyReadBackupRecoveryKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyReadBackupRecoveryKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyReadBackupRecoveryKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-delete-backup-recovery-key.type.d.ts
interface RekeyDeleteBackupRecoveryKeyResponseBodies {
  204: void;
}
type RekeyDeleteBackupRecoveryKeyRequestQuery = {};
type RekeyDeleteBackupRecoveryKeyRouteParameters = {};
type RekeyDeleteBackupRecoveryKeyRequestHeaders = {};
type RekeyDeleteBackupRecoveryKeyRequestParameters = RekeyDeleteBackupRecoveryKeyRequestQuery & RekeyDeleteBackupRecoveryKeyRouteParameters & RekeyDeleteBackupRecoveryKeyRequestHeaders;
interface RekeyDeleteBackupRecoveryKeyOperation<STATUS extends keyof RekeyDeleteBackupRecoveryKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyDeleteBackupRecoveryKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyDeleteBackupRecoveryKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyDeleteBackupRecoveryKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyDeleteBackupRecoveryKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-attempt-update-request.schema.d.ts
interface RekeyAttemptUpdateRequest {
  /**
   * Specifies a single unseal key share.
   */
  key?: string;
  /**
   * Specifies the nonce of the rekey attempt.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-attempt-update-response.schema.d.ts
interface RekeyAttemptUpdateResponse {
  backup?: boolean;
  complete?: boolean;
  keys?: string[];
  keys_base64?: string[];
  n?: number;
  nounce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: string;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-attempt-update.type.d.ts
interface RekeyAttemptUpdateResponseBodies {
  200: RekeyAttemptUpdateResponse;
}
interface RekeyAttemptUpdateRequestBodies {
  'application/json': RekeyAttemptUpdateRequest;
}
type RekeyAttemptUpdateRequestQuery = {};
type RekeyAttemptUpdateRouteParameters = {};
type RekeyAttemptUpdateRequestHeaders = {};
interface RekeyAttemptUpdateParameterBodies {
  'application/json': RekeyAttemptUpdateRequest & {
    [key: string]: any;
  };
}
type RekeyAttemptUpdateRequestParameters = RekeyAttemptUpdateRequestQuery & RekeyAttemptUpdateRouteParameters & RekeyAttemptUpdateRequestHeaders & RekeyAttemptUpdateRequestBodies['application/json'];
interface RekeyAttemptUpdateOperation<STATUS extends keyof RekeyAttemptUpdateResponseBodies, CONTENT_TYPE extends keyof RekeyAttemptUpdateParameterBodies> extends KeqOperation {
  requestParams: RekeyAttemptUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyAttemptUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyAttemptUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RekeyAttemptUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RekeyAttemptUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-verification-read-progress-response.schema.d.ts
interface RekeyVerificationReadProgressResponse {
  n?: number;
  nounce?: string;
  progress?: number;
  started?: string;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-verification-read-progress.type.d.ts
interface RekeyVerificationReadProgressResponseBodies {
  200: RekeyVerificationReadProgressResponse;
}
type RekeyVerificationReadProgressRequestQuery = {};
type RekeyVerificationReadProgressRouteParameters = {};
type RekeyVerificationReadProgressRequestHeaders = {};
type RekeyVerificationReadProgressRequestParameters = RekeyVerificationReadProgressRequestQuery & RekeyVerificationReadProgressRouteParameters & RekeyVerificationReadProgressRequestHeaders;
interface RekeyVerificationReadProgressOperation<STATUS extends keyof RekeyVerificationReadProgressResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyVerificationReadProgressRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyVerificationReadProgressRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyVerificationReadProgressRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyVerificationReadProgressResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-verification-update-request.schema.d.ts
interface RekeyVerificationUpdateRequest {
  /**
   * Specifies a single unseal share key from the new set of shares.
   */
  key?: string;
  /**
   * Specifies the nonce of the rekey verification operation.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-verification-update-response.schema.d.ts
interface RekeyVerificationUpdateResponse {
  complete?: boolean;
  nounce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-verification-update.type.d.ts
interface RekeyVerificationUpdateResponseBodies {
  200: RekeyVerificationUpdateResponse;
}
interface RekeyVerificationUpdateRequestBodies {
  'application/json': RekeyVerificationUpdateRequest;
}
type RekeyVerificationUpdateRequestQuery = {};
type RekeyVerificationUpdateRouteParameters = {};
type RekeyVerificationUpdateRequestHeaders = {};
interface RekeyVerificationUpdateParameterBodies {
  'application/json': RekeyVerificationUpdateRequest & {
    [key: string]: any;
  };
}
type RekeyVerificationUpdateRequestParameters = RekeyVerificationUpdateRequestQuery & RekeyVerificationUpdateRouteParameters & RekeyVerificationUpdateRequestHeaders & RekeyVerificationUpdateRequestBodies['application/json'];
interface RekeyVerificationUpdateOperation<STATUS extends keyof RekeyVerificationUpdateResponseBodies, CONTENT_TYPE extends keyof RekeyVerificationUpdateParameterBodies> extends KeqOperation {
  requestParams: RekeyVerificationUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyVerificationUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyVerificationUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RekeyVerificationUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RekeyVerificationUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rekey-verification-cancel-response.schema.d.ts
interface RekeyVerificationCancelResponse {
  n?: number;
  nounce?: string;
  progress?: number;
  started?: string;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rekey-verification-cancel.type.d.ts
interface RekeyVerificationCancelResponseBodies {
  200: RekeyVerificationCancelResponse;
}
type RekeyVerificationCancelRequestQuery = {};
type RekeyVerificationCancelRouteParameters = {};
type RekeyVerificationCancelRequestHeaders = {};
type RekeyVerificationCancelRequestParameters = RekeyVerificationCancelRequestQuery & RekeyVerificationCancelRouteParameters & RekeyVerificationCancelRequestHeaders;
interface RekeyVerificationCancelOperation<STATUS extends keyof RekeyVerificationCancelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RekeyVerificationCancelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RekeyVerificationCancelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RekeyVerificationCancelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RekeyVerificationCancelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/remount-request.schema.d.ts
interface RemountRequest {
  /**
   * The previous mount point.
   */
  from?: string;
  /**
   * The new mount point.
   */
  to?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/remount-response.schema.d.ts
interface RemountResponse {
  migration_id?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/remount.type.d.ts
interface RemountResponseBodies {
  200: RemountResponse;
}
interface RemountRequestBodies {
  'application/json': RemountRequest;
}
type RemountRequestQuery = {};
type RemountRouteParameters = {};
type RemountRequestHeaders = {};
interface RemountParameterBodies {
  'application/json': RemountRequest & {
    [key: string]: any;
  };
}
type RemountRequestParameters = RemountRequestQuery & RemountRouteParameters & RemountRequestHeaders & RemountRequestBodies['application/json'];
interface RemountOperation<STATUS extends keyof RemountResponseBodies, CONTENT_TYPE extends keyof RemountParameterBodies> extends KeqOperation {
  requestParams: RemountRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RemountRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RemountRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RemountParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RemountResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/remount-status-response.schema.d.ts
interface RemountStatusResponse {
  migration_id?: string;
  /**
   * @format map
   */
  migration_info?: Record<string, never>;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/remount-status.type.d.ts
interface RemountStatusResponseBodies {
  200: RemountStatusResponse;
}
type RemountStatusRequestQuery = {};
type RemountStatusRouteParameters = {};
type RemountStatusRequestHeaders = {};
type RemountStatusRequestParameters = RemountStatusRequestQuery & RemountStatusRouteParameters & RemountStatusRequestHeaders;
interface RemountStatusOperation<STATUS extends keyof RemountStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RemountStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RemountStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RemountStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RemountStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-rotate.type.d.ts
interface EncryptionKeyRotateResponseBodies {
  204: void;
}
type EncryptionKeyRotateRequestQuery = {};
type EncryptionKeyRotateRouteParameters = {};
type EncryptionKeyRotateRequestHeaders = {};
type EncryptionKeyRotateRequestParameters = EncryptionKeyRotateRequestQuery & EncryptionKeyRotateRouteParameters & EncryptionKeyRotateRequestHeaders;
interface EncryptionKeyRotateOperation<STATUS extends keyof EncryptionKeyRotateResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EncryptionKeyRotateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyRotateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyRotateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EncryptionKeyRotateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/encryption-key-read-rotation-configuration-response.schema.d.ts
interface EncryptionKeyReadRotationConfigurationResponse {
  /**
   * Whether automatic rotation is enabled.
   */
  enabled?: boolean;
  /**
   * How long after installation of an active key term that the key will be automatically rotated.
   * @format seconds
   */
  interval?: number;
  /**
   * The number of encryption operations performed before the barrier key is automatically rotated.
   * @format int64
   */
  max_operations?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-read-rotation-configuration.type.d.ts
interface EncryptionKeyReadRotationConfigurationResponseBodies {
  200: EncryptionKeyReadRotationConfigurationResponse;
}
type EncryptionKeyReadRotationConfigurationRequestQuery = {};
type EncryptionKeyReadRotationConfigurationRouteParameters = {};
type EncryptionKeyReadRotationConfigurationRequestHeaders = {};
type EncryptionKeyReadRotationConfigurationRequestParameters = EncryptionKeyReadRotationConfigurationRequestQuery & EncryptionKeyReadRotationConfigurationRouteParameters & EncryptionKeyReadRotationConfigurationRequestHeaders;
interface EncryptionKeyReadRotationConfigurationOperation<STATUS extends keyof EncryptionKeyReadRotationConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EncryptionKeyReadRotationConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyReadRotationConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyReadRotationConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EncryptionKeyReadRotationConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/encryption-key-configure-rotation-configuration-request.schema.d.ts
interface EncryptionKeyConfigureRotationConfigurationRequest {
  /**
   * Whether automatic rotation is enabled.
   */
  enabled?: boolean;
  /**
   * How long after installation of an active key term that the key will be automatically rotated.
   * @format seconds
   */
  interval?: number;
  /**
   * The number of encryption operations performed before the barrier key is automatically rotated.
   * @format int64
   */
  max_operations?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-configure-rotation-configuration.type.d.ts
interface EncryptionKeyConfigureRotationConfigurationResponseBodies {
  204: void;
}
interface EncryptionKeyConfigureRotationConfigurationRequestBodies {
  'application/json': EncryptionKeyConfigureRotationConfigurationRequest;
}
type EncryptionKeyConfigureRotationConfigurationRequestQuery = {};
type EncryptionKeyConfigureRotationConfigurationRouteParameters = {};
type EncryptionKeyConfigureRotationConfigurationRequestHeaders = {};
interface EncryptionKeyConfigureRotationConfigurationParameterBodies {
  'application/json': EncryptionKeyConfigureRotationConfigurationRequest & {
    [key: string]: any;
  };
}
type EncryptionKeyConfigureRotationConfigurationRequestParameters = EncryptionKeyConfigureRotationConfigurationRequestQuery & EncryptionKeyConfigureRotationConfigurationRouteParameters & EncryptionKeyConfigureRotationConfigurationRequestHeaders & EncryptionKeyConfigureRotationConfigurationRequestBodies['application/json'];
interface EncryptionKeyConfigureRotationConfigurationOperation<STATUS extends keyof EncryptionKeyConfigureRotationConfigurationResponseBodies, CONTENT_TYPE extends keyof EncryptionKeyConfigureRotationConfigurationParameterBodies> extends KeqOperation {
  requestParams: EncryptionKeyConfigureRotationConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyConfigureRotationConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyConfigureRotationConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EncryptionKeyConfigureRotationConfigurationParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EncryptionKeyConfigureRotationConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-rotate-rotate-keyring.type.d.ts
interface EncryptionKeyRotateRotateKeyringResponseBodies {
  204: void;
}
type EncryptionKeyRotateRotateKeyringRequestQuery = {};
type EncryptionKeyRotateRotateKeyringRouteParameters = {};
type EncryptionKeyRotateRotateKeyringRequestHeaders = {};
type EncryptionKeyRotateRotateKeyringRequestParameters = EncryptionKeyRotateRotateKeyringRequestQuery & EncryptionKeyRotateRotateKeyringRouteParameters & EncryptionKeyRotateRotateKeyringRequestHeaders;
interface EncryptionKeyRotateRotateKeyringOperation<STATUS extends keyof EncryptionKeyRotateRotateKeyringResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EncryptionKeyRotateRotateKeyringRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyRotateRotateKeyringRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyRotateRotateKeyringRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EncryptionKeyRotateRotateKeyringResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/encryption-key-read-rotate-keyring-config-response.schema.d.ts
interface EncryptionKeyReadRotateKeyringConfigResponse {
  /**
   * Whether automatic rotation is enabled.
   */
  enabled?: boolean;
  /**
   * How long after installation of an active key term that the key will be automatically rotated.
   * @format seconds
   */
  interval?: number;
  /**
   * The number of encryption operations performed before the barrier key is automatically rotated.
   * @format int64
   */
  max_operations?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-read-rotate-keyring-config.type.d.ts
interface EncryptionKeyReadRotateKeyringConfigResponseBodies {
  200: EncryptionKeyReadRotateKeyringConfigResponse;
}
type EncryptionKeyReadRotateKeyringConfigRequestQuery = {};
type EncryptionKeyReadRotateKeyringConfigRouteParameters = {};
type EncryptionKeyReadRotateKeyringConfigRequestHeaders = {};
type EncryptionKeyReadRotateKeyringConfigRequestParameters = EncryptionKeyReadRotateKeyringConfigRequestQuery & EncryptionKeyReadRotateKeyringConfigRouteParameters & EncryptionKeyReadRotateKeyringConfigRequestHeaders;
interface EncryptionKeyReadRotateKeyringConfigOperation<STATUS extends keyof EncryptionKeyReadRotateKeyringConfigResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: EncryptionKeyReadRotateKeyringConfigRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyReadRotateKeyringConfigRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyReadRotateKeyringConfigRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: EncryptionKeyReadRotateKeyringConfigResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/encryption-key-configure-rotate-keyring-config-request.schema.d.ts
interface EncryptionKeyConfigureRotateKeyringConfigRequest {
  /**
   * Whether automatic rotation is enabled.
   */
  enabled?: boolean;
  /**
   * How long after installation of an active key term that the key will be automatically rotated.
   * @format seconds
   */
  interval?: number;
  /**
   * The number of encryption operations performed before the barrier key is automatically rotated.
   * @format int64
   */
  max_operations?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/encryption-key-configure-rotate-keyring-config.type.d.ts
interface EncryptionKeyConfigureRotateKeyringConfigResponseBodies {
  204: void;
}
interface EncryptionKeyConfigureRotateKeyringConfigRequestBodies {
  'application/json': EncryptionKeyConfigureRotateKeyringConfigRequest;
}
type EncryptionKeyConfigureRotateKeyringConfigRequestQuery = {};
type EncryptionKeyConfigureRotateKeyringConfigRouteParameters = {};
type EncryptionKeyConfigureRotateKeyringConfigRequestHeaders = {};
interface EncryptionKeyConfigureRotateKeyringConfigParameterBodies {
  'application/json': EncryptionKeyConfigureRotateKeyringConfigRequest & {
    [key: string]: any;
  };
}
type EncryptionKeyConfigureRotateKeyringConfigRequestParameters = EncryptionKeyConfigureRotateKeyringConfigRequestQuery & EncryptionKeyConfigureRotateKeyringConfigRouteParameters & EncryptionKeyConfigureRotateKeyringConfigRequestHeaders & EncryptionKeyConfigureRotateKeyringConfigRequestBodies['application/json'];
interface EncryptionKeyConfigureRotateKeyringConfigOperation<STATUS extends keyof EncryptionKeyConfigureRotateKeyringConfigResponseBodies, CONTENT_TYPE extends keyof EncryptionKeyConfigureRotateKeyringConfigParameterBodies> extends KeqOperation {
  requestParams: EncryptionKeyConfigureRotateKeyringConfigRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: EncryptionKeyConfigureRotateKeyringConfigRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: EncryptionKeyConfigureRotateKeyringConfigRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: EncryptionKeyConfigureRotateKeyringConfigParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: EncryptionKeyConfigureRotateKeyringConfigResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-read-rotate-recovery-backup-response.schema.d.ts
interface RotateReadRotateRecoveryBackupResponse {
  keys?: string[];
  keys_base64?: string[];
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-read-rotate-recovery-backup.type.d.ts
interface RotateReadRotateRecoveryBackupResponseBodies {
  200: RotateReadRotateRecoveryBackupResponse;
}
type RotateReadRotateRecoveryBackupRequestQuery = {};
type RotateReadRotateRecoveryBackupRouteParameters = {};
type RotateReadRotateRecoveryBackupRequestHeaders = {};
type RotateReadRotateRecoveryBackupRequestParameters = RotateReadRotateRecoveryBackupRequestQuery & RotateReadRotateRecoveryBackupRouteParameters & RotateReadRotateRecoveryBackupRequestHeaders;
interface RotateReadRotateRecoveryBackupOperation<STATUS extends keyof RotateReadRotateRecoveryBackupResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateReadRotateRecoveryBackupRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateReadRotateRecoveryBackupRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateReadRotateRecoveryBackupRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateReadRotateRecoveryBackupResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-delete-rotate-recovery-backup.type.d.ts
interface RotateDeleteRotateRecoveryBackupResponseBodies {
  204: void;
}
type RotateDeleteRotateRecoveryBackupRequestQuery = {};
type RotateDeleteRotateRecoveryBackupRouteParameters = {};
type RotateDeleteRotateRecoveryBackupRequestHeaders = {};
type RotateDeleteRotateRecoveryBackupRequestParameters = RotateDeleteRotateRecoveryBackupRequestQuery & RotateDeleteRotateRecoveryBackupRouteParameters & RotateDeleteRotateRecoveryBackupRequestHeaders;
interface RotateDeleteRotateRecoveryBackupOperation<STATUS extends keyof RotateDeleteRotateRecoveryBackupResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateDeleteRotateRecoveryBackupRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateDeleteRotateRecoveryBackupRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateDeleteRotateRecoveryBackupRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateDeleteRotateRecoveryBackupResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-read-rotate-recovery-init-response.schema.d.ts
interface RotateAttemptReadRotateRecoveryInitResponse {
  /**
   * Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys.
   */
  backup?: boolean;
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys.
   */
  pgp_keys?: string[];
  /**
   * Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated.
   */
  require_verification?: boolean;
  /**
   * Specifies the number of shares to split the root key into.
   */
  secret_shares?: number;
  /**
   * Specifies the number of shares required to reconstruct the root key.
   */
  secret_threshold?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-read-rotate-recovery-init.type.d.ts
interface RotateAttemptReadRotateRecoveryInitResponseBodies {
  200: RotateAttemptReadRotateRecoveryInitResponse;
}
type RotateAttemptReadRotateRecoveryInitRequestQuery = {};
type RotateAttemptReadRotateRecoveryInitRouteParameters = {};
type RotateAttemptReadRotateRecoveryInitRequestHeaders = {};
type RotateAttemptReadRotateRecoveryInitRequestParameters = RotateAttemptReadRotateRecoveryInitRequestQuery & RotateAttemptReadRotateRecoveryInitRouteParameters & RotateAttemptReadRotateRecoveryInitRequestHeaders;
interface RotateAttemptReadRotateRecoveryInitOperation<STATUS extends keyof RotateAttemptReadRotateRecoveryInitResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateAttemptReadRotateRecoveryInitRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptReadRotateRecoveryInitRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptReadRotateRecoveryInitRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateAttemptReadRotateRecoveryInitResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-initialize-rotate-recovery-init-request.schema.d.ts
interface RotateAttemptInitializeRotateRecoveryInitRequest {
  /**
   * Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys.
   */
  backup?: boolean;
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys.
   */
  pgp_keys?: string[];
  /**
   * Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated.
   */
  require_verification?: boolean;
  /**
   * Specifies the number of shares to split the root key into.
   */
  secret_shares: number;
  /**
   * Specifies the number of shares required to reconstruct the root key.
   */
  secret_threshold: number;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-initialize-rotate-recovery-init-response.schema.d.ts
interface RotateAttemptInitializeRotateRecoveryInitResponse {
  backup?: boolean;
  complete?: boolean;
  keys?: string[];
  keys_base64?: string[];
  n?: number;
  nonce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: boolean;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-initialize-rotate-recovery-init.type.d.ts
interface RotateAttemptInitializeRotateRecoveryInitResponseBodies {
  200: RotateAttemptInitializeRotateRecoveryInitResponse;
}
interface RotateAttemptInitializeRotateRecoveryInitRequestBodies {
  'application/json': RotateAttemptInitializeRotateRecoveryInitRequest;
}
type RotateAttemptInitializeRotateRecoveryInitRequestQuery = {};
type RotateAttemptInitializeRotateRecoveryInitRouteParameters = {};
type RotateAttemptInitializeRotateRecoveryInitRequestHeaders = {};
interface RotateAttemptInitializeRotateRecoveryInitParameterBodies {
  'application/json': RotateAttemptInitializeRotateRecoveryInitRequest & {
    [key: string]: any;
  };
}
type RotateAttemptInitializeRotateRecoveryInitRequestParameters = RotateAttemptInitializeRotateRecoveryInitRequestQuery & RotateAttemptInitializeRotateRecoveryInitRouteParameters & RotateAttemptInitializeRotateRecoveryInitRequestHeaders & RotateAttemptInitializeRotateRecoveryInitRequestBodies['application/json'];
interface RotateAttemptInitializeRotateRecoveryInitOperation<STATUS extends keyof RotateAttemptInitializeRotateRecoveryInitResponseBodies, CONTENT_TYPE extends keyof RotateAttemptInitializeRotateRecoveryInitParameterBodies> extends KeqOperation {
  requestParams: RotateAttemptInitializeRotateRecoveryInitRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptInitializeRotateRecoveryInitRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptInitializeRotateRecoveryInitRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateAttemptInitializeRotateRecoveryInitParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateAttemptInitializeRotateRecoveryInitResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-cancel-rotate-recovery-init.type.d.ts
interface RotateAttemptCancelRotateRecoveryInitResponseBodies {
  204: void;
}
type RotateAttemptCancelRotateRecoveryInitRequestQuery = {};
type RotateAttemptCancelRotateRecoveryInitRouteParameters = {};
type RotateAttemptCancelRotateRecoveryInitRequestHeaders = {};
type RotateAttemptCancelRotateRecoveryInitRequestParameters = RotateAttemptCancelRotateRecoveryInitRequestQuery & RotateAttemptCancelRotateRecoveryInitRouteParameters & RotateAttemptCancelRotateRecoveryInitRequestHeaders;
interface RotateAttemptCancelRotateRecoveryInitOperation<STATUS extends keyof RotateAttemptCancelRotateRecoveryInitResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateAttemptCancelRotateRecoveryInitRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptCancelRotateRecoveryInitRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptCancelRotateRecoveryInitRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateAttemptCancelRotateRecoveryInitResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-update-rotate-recovery-update-request.schema.d.ts
interface RotateAttemptUpdateRotateRecoveryUpdateRequest {
  /**
   * Specifies a single unseal key share.
   */
  key?: string;
  /**
   * Specifies the nonce of the rotation attempt.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-update-rotate-recovery-update-response.schema.d.ts
interface RotateAttemptUpdateRotateRecoveryUpdateResponse {
  backup?: boolean;
  complete?: boolean;
  keys?: string[];
  keys_base64?: string[];
  n?: number;
  nonce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: boolean;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-update-rotate-recovery-update.type.d.ts
interface RotateAttemptUpdateRotateRecoveryUpdateResponseBodies {
  200: RotateAttemptUpdateRotateRecoveryUpdateResponse;
}
interface RotateAttemptUpdateRotateRecoveryUpdateRequestBodies {
  'application/json': RotateAttemptUpdateRotateRecoveryUpdateRequest;
}
type RotateAttemptUpdateRotateRecoveryUpdateRequestQuery = {};
type RotateAttemptUpdateRotateRecoveryUpdateRouteParameters = {};
type RotateAttemptUpdateRotateRecoveryUpdateRequestHeaders = {};
interface RotateAttemptUpdateRotateRecoveryUpdateParameterBodies {
  'application/json': RotateAttemptUpdateRotateRecoveryUpdateRequest & {
    [key: string]: any;
  };
}
type RotateAttemptUpdateRotateRecoveryUpdateRequestParameters = RotateAttemptUpdateRotateRecoveryUpdateRequestQuery & RotateAttemptUpdateRotateRecoveryUpdateRouteParameters & RotateAttemptUpdateRotateRecoveryUpdateRequestHeaders & RotateAttemptUpdateRotateRecoveryUpdateRequestBodies['application/json'];
interface RotateAttemptUpdateRotateRecoveryUpdateOperation<STATUS extends keyof RotateAttemptUpdateRotateRecoveryUpdateResponseBodies, CONTENT_TYPE extends keyof RotateAttemptUpdateRotateRecoveryUpdateParameterBodies> extends KeqOperation {
  requestParams: RotateAttemptUpdateRotateRecoveryUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptUpdateRotateRecoveryUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptUpdateRotateRecoveryUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateAttemptUpdateRotateRecoveryUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateAttemptUpdateRotateRecoveryUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-read-rotate-recovery-verify-response.schema.d.ts
interface RotateVerificationReadRotateRecoveryVerifyResponse {
  n?: number;
  nonce?: string;
  progress?: number;
  started?: boolean;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-read-rotate-recovery-verify.type.d.ts
interface RotateVerificationReadRotateRecoveryVerifyResponseBodies {
  200: RotateVerificationReadRotateRecoveryVerifyResponse;
}
type RotateVerificationReadRotateRecoveryVerifyRequestQuery = {};
type RotateVerificationReadRotateRecoveryVerifyRouteParameters = {};
type RotateVerificationReadRotateRecoveryVerifyRequestHeaders = {};
type RotateVerificationReadRotateRecoveryVerifyRequestParameters = RotateVerificationReadRotateRecoveryVerifyRequestQuery & RotateVerificationReadRotateRecoveryVerifyRouteParameters & RotateVerificationReadRotateRecoveryVerifyRequestHeaders;
interface RotateVerificationReadRotateRecoveryVerifyOperation<STATUS extends keyof RotateVerificationReadRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateVerificationReadRotateRecoveryVerifyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationReadRotateRecoveryVerifyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationReadRotateRecoveryVerifyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateVerificationReadRotateRecoveryVerifyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-update-rotate-recovery-verify-request.schema.d.ts
interface RotateVerificationUpdateRotateRecoveryVerifyRequest {
  /**
   * Specifies a single unseal share key from the new set of shares.
   */
  key?: string;
  /**
   * Specifies the nonce of the rotation verification operation.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-update-rotate-recovery-verify-response.schema.d.ts
interface RotateVerificationUpdateRotateRecoveryVerifyResponse {
  complete?: boolean;
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-update-rotate-recovery-verify.type.d.ts
interface RotateVerificationUpdateRotateRecoveryVerifyResponseBodies {
  200: RotateVerificationUpdateRotateRecoveryVerifyResponse;
}
interface RotateVerificationUpdateRotateRecoveryVerifyRequestBodies {
  'application/json': RotateVerificationUpdateRotateRecoveryVerifyRequest;
}
type RotateVerificationUpdateRotateRecoveryVerifyRequestQuery = {};
type RotateVerificationUpdateRotateRecoveryVerifyRouteParameters = {};
type RotateVerificationUpdateRotateRecoveryVerifyRequestHeaders = {};
interface RotateVerificationUpdateRotateRecoveryVerifyParameterBodies {
  'application/json': RotateVerificationUpdateRotateRecoveryVerifyRequest & {
    [key: string]: any;
  };
}
type RotateVerificationUpdateRotateRecoveryVerifyRequestParameters = RotateVerificationUpdateRotateRecoveryVerifyRequestQuery & RotateVerificationUpdateRotateRecoveryVerifyRouteParameters & RotateVerificationUpdateRotateRecoveryVerifyRequestHeaders & RotateVerificationUpdateRotateRecoveryVerifyRequestBodies['application/json'];
interface RotateVerificationUpdateRotateRecoveryVerifyOperation<STATUS extends keyof RotateVerificationUpdateRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends keyof RotateVerificationUpdateRotateRecoveryVerifyParameterBodies> extends KeqOperation {
  requestParams: RotateVerificationUpdateRotateRecoveryVerifyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationUpdateRotateRecoveryVerifyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationUpdateRotateRecoveryVerifyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateVerificationUpdateRotateRecoveryVerifyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateVerificationUpdateRotateRecoveryVerifyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-cancel-rotate-recovery-verify-response.schema.d.ts
interface RotateVerificationCancelRotateRecoveryVerifyResponse {
  n?: number;
  nonce?: string;
  progress?: number;
  started?: boolean;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-cancel-rotate-recovery-verify.type.d.ts
interface RotateVerificationCancelRotateRecoveryVerifyResponseBodies {
  200: RotateVerificationCancelRotateRecoveryVerifyResponse;
}
type RotateVerificationCancelRotateRecoveryVerifyRequestQuery = {};
type RotateVerificationCancelRotateRecoveryVerifyRouteParameters = {};
type RotateVerificationCancelRotateRecoveryVerifyRequestHeaders = {};
type RotateVerificationCancelRotateRecoveryVerifyRequestParameters = RotateVerificationCancelRotateRecoveryVerifyRequestQuery & RotateVerificationCancelRotateRecoveryVerifyRouteParameters & RotateVerificationCancelRotateRecoveryVerifyRequestHeaders;
interface RotateVerificationCancelRotateRecoveryVerifyOperation<STATUS extends keyof RotateVerificationCancelRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateVerificationCancelRotateRecoveryVerifyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationCancelRotateRecoveryVerifyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationCancelRotateRecoveryVerifyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateVerificationCancelRotateRecoveryVerifyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/root-key-rotate.type.d.ts
interface RootKeyRotateResponseBodies {
  204: void;
}
type RootKeyRotateRequestQuery = {};
type RootKeyRotateRouteParameters = {};
type RootKeyRotateRequestHeaders = {};
type RootKeyRotateRequestParameters = RootKeyRotateRequestQuery & RootKeyRotateRouteParameters & RootKeyRotateRequestHeaders;
interface RootKeyRotateOperation<STATUS extends keyof RootKeyRotateResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RootKeyRotateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RootKeyRotateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RootKeyRotateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RootKeyRotateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-read-backup-key-response.schema.d.ts
interface RotateReadBackupKeyResponse {
  keys?: string[];
  keys_base64?: string[];
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-read-backup-key.type.d.ts
interface RotateReadBackupKeyResponseBodies {
  200: RotateReadBackupKeyResponse;
}
type RotateReadBackupKeyRequestQuery = {};
type RotateReadBackupKeyRouteParameters = {};
type RotateReadBackupKeyRequestHeaders = {};
type RotateReadBackupKeyRequestParameters = RotateReadBackupKeyRequestQuery & RotateReadBackupKeyRouteParameters & RotateReadBackupKeyRequestHeaders;
interface RotateReadBackupKeyOperation<STATUS extends keyof RotateReadBackupKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateReadBackupKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateReadBackupKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateReadBackupKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateReadBackupKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-delete-backup-key.type.d.ts
interface RotateDeleteBackupKeyResponseBodies {
  204: void;
}
type RotateDeleteBackupKeyRequestQuery = {};
type RotateDeleteBackupKeyRouteParameters = {};
type RotateDeleteBackupKeyRequestHeaders = {};
type RotateDeleteBackupKeyRequestParameters = RotateDeleteBackupKeyRequestQuery & RotateDeleteBackupKeyRouteParameters & RotateDeleteBackupKeyRequestHeaders;
interface RotateDeleteBackupKeyOperation<STATUS extends keyof RotateDeleteBackupKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateDeleteBackupKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateDeleteBackupKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateDeleteBackupKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateDeleteBackupKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-read-progress-response.schema.d.ts
interface RotateAttemptReadProgressResponse {
  /**
   * Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys.
   */
  backup?: boolean;
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys.
   */
  pgp_keys?: string[];
  /**
   * Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated.
   */
  require_verification?: boolean;
  /**
   * Specifies the number of shares to split the root key into.
   */
  secret_shares?: number;
  /**
   * Specifies the number of shares required to reconstruct the root key.
   */
  secret_threshold?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-read-progress.type.d.ts
interface RotateAttemptReadProgressResponseBodies {
  200: RotateAttemptReadProgressResponse;
}
type RotateAttemptReadProgressRequestQuery = {};
type RotateAttemptReadProgressRouteParameters = {};
type RotateAttemptReadProgressRequestHeaders = {};
type RotateAttemptReadProgressRequestParameters = RotateAttemptReadProgressRequestQuery & RotateAttemptReadProgressRouteParameters & RotateAttemptReadProgressRequestHeaders;
interface RotateAttemptReadProgressOperation<STATUS extends keyof RotateAttemptReadProgressResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateAttemptReadProgressRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptReadProgressRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptReadProgressRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateAttemptReadProgressResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-initialize-request.schema.d.ts
interface RotateAttemptInitializeRequest {
  /**
   * Specifies if using PGP-encrypted keys, whether OpenBao should also store a plaintext backup of the said keys.
   */
  backup?: boolean;
  /**
   * Specifies an array of PGP public keys used to encrypt the output unseal keys.
   */
  pgp_keys?: string[];
  /**
   * Enables verification which after successful authorization with the current unseal keys, ensures the new unseal keys are returned but the root key is not actually rotated.
   */
  require_verification?: boolean;
  /**
   * Specifies the number of shares to split the root key into.
   */
  secret_shares: number;
  /**
   * Specifies the number of shares required to reconstruct the root key.
   */
  secret_threshold: number;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-initialize-response.schema.d.ts
interface RotateAttemptInitializeResponse {
  backup?: boolean;
  complete?: boolean;
  keys?: string[];
  keys_base64?: string[];
  n?: number;
  nonce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: boolean;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-initialize.type.d.ts
interface RotateAttemptInitializeResponseBodies {
  200: RotateAttemptInitializeResponse;
}
interface RotateAttemptInitializeRequestBodies {
  'application/json': RotateAttemptInitializeRequest;
}
type RotateAttemptInitializeRequestQuery = {};
type RotateAttemptInitializeRouteParameters = {};
type RotateAttemptInitializeRequestHeaders = {};
interface RotateAttemptInitializeParameterBodies {
  'application/json': RotateAttemptInitializeRequest & {
    [key: string]: any;
  };
}
type RotateAttemptInitializeRequestParameters = RotateAttemptInitializeRequestQuery & RotateAttemptInitializeRouteParameters & RotateAttemptInitializeRequestHeaders & RotateAttemptInitializeRequestBodies['application/json'];
interface RotateAttemptInitializeOperation<STATUS extends keyof RotateAttemptInitializeResponseBodies, CONTENT_TYPE extends keyof RotateAttemptInitializeParameterBodies> extends KeqOperation {
  requestParams: RotateAttemptInitializeRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptInitializeRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptInitializeRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateAttemptInitializeParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateAttemptInitializeResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-cancel.type.d.ts
interface RotateAttemptCancelResponseBodies {
  204: void;
}
type RotateAttemptCancelRequestQuery = {};
type RotateAttemptCancelRouteParameters = {};
type RotateAttemptCancelRequestHeaders = {};
type RotateAttemptCancelRequestParameters = RotateAttemptCancelRequestQuery & RotateAttemptCancelRouteParameters & RotateAttemptCancelRequestHeaders;
interface RotateAttemptCancelOperation<STATUS extends keyof RotateAttemptCancelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateAttemptCancelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptCancelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptCancelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateAttemptCancelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-update-request.schema.d.ts
interface RotateAttemptUpdateRequest {
  /**
   * Specifies a single unseal key share.
   */
  key?: string;
  /**
   * Specifies the nonce of the rotation attempt.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-attempt-update-response.schema.d.ts
interface RotateAttemptUpdateResponse {
  backup?: boolean;
  complete?: boolean;
  keys?: string[];
  keys_base64?: string[];
  n?: number;
  nonce?: string;
  pgp_fingerprints?: string[];
  progress?: number;
  required?: number;
  started?: boolean;
  t?: number;
  verification_nonce?: string;
  verification_required?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-attempt-update.type.d.ts
interface RotateAttemptUpdateResponseBodies {
  200: RotateAttemptUpdateResponse;
}
interface RotateAttemptUpdateRequestBodies {
  'application/json': RotateAttemptUpdateRequest;
}
type RotateAttemptUpdateRequestQuery = {};
type RotateAttemptUpdateRouteParameters = {};
type RotateAttemptUpdateRequestHeaders = {};
interface RotateAttemptUpdateParameterBodies {
  'application/json': RotateAttemptUpdateRequest & {
    [key: string]: any;
  };
}
type RotateAttemptUpdateRequestParameters = RotateAttemptUpdateRequestQuery & RotateAttemptUpdateRouteParameters & RotateAttemptUpdateRequestHeaders & RotateAttemptUpdateRequestBodies['application/json'];
interface RotateAttemptUpdateOperation<STATUS extends keyof RotateAttemptUpdateResponseBodies, CONTENT_TYPE extends keyof RotateAttemptUpdateParameterBodies> extends KeqOperation {
  requestParams: RotateAttemptUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateAttemptUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateAttemptUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateAttemptUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateAttemptUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-read-progress-response.schema.d.ts
interface RotateVerificationReadProgressResponse {
  n?: number;
  nonce?: string;
  progress?: number;
  started?: boolean;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-read-progress.type.d.ts
interface RotateVerificationReadProgressResponseBodies {
  200: RotateVerificationReadProgressResponse;
}
type RotateVerificationReadProgressRequestQuery = {};
type RotateVerificationReadProgressRouteParameters = {};
type RotateVerificationReadProgressRequestHeaders = {};
type RotateVerificationReadProgressRequestParameters = RotateVerificationReadProgressRequestQuery & RotateVerificationReadProgressRouteParameters & RotateVerificationReadProgressRequestHeaders;
interface RotateVerificationReadProgressOperation<STATUS extends keyof RotateVerificationReadProgressResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateVerificationReadProgressRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationReadProgressRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationReadProgressRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateVerificationReadProgressResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-update-request.schema.d.ts
interface RotateVerificationUpdateRequest {
  /**
   * Specifies a single unseal share key from the new set of shares.
   */
  key?: string;
  /**
   * Specifies the nonce of the rotation verification operation.
   */
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-update-response.schema.d.ts
interface RotateVerificationUpdateResponse {
  complete?: boolean;
  nonce?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-update.type.d.ts
interface RotateVerificationUpdateResponseBodies {
  200: RotateVerificationUpdateResponse;
}
interface RotateVerificationUpdateRequestBodies {
  'application/json': RotateVerificationUpdateRequest;
}
type RotateVerificationUpdateRequestQuery = {};
type RotateVerificationUpdateRouteParameters = {};
type RotateVerificationUpdateRequestHeaders = {};
interface RotateVerificationUpdateParameterBodies {
  'application/json': RotateVerificationUpdateRequest & {
    [key: string]: any;
  };
}
type RotateVerificationUpdateRequestParameters = RotateVerificationUpdateRequestQuery & RotateVerificationUpdateRouteParameters & RotateVerificationUpdateRequestHeaders & RotateVerificationUpdateRequestBodies['application/json'];
interface RotateVerificationUpdateOperation<STATUS extends keyof RotateVerificationUpdateResponseBodies, CONTENT_TYPE extends keyof RotateVerificationUpdateParameterBodies> extends KeqOperation {
  requestParams: RotateVerificationUpdateRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationUpdateRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationUpdateRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RotateVerificationUpdateParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RotateVerificationUpdateResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rotate-verification-cancel-response.schema.d.ts
interface RotateVerificationCancelResponse {
  n?: number;
  nonce?: string;
  progress?: number;
  started?: boolean;
  t?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rotate-verification-cancel.type.d.ts
interface RotateVerificationCancelResponseBodies {
  200: RotateVerificationCancelResponse;
}
type RotateVerificationCancelRequestQuery = {};
type RotateVerificationCancelRouteParameters = {};
type RotateVerificationCancelRequestHeaders = {};
type RotateVerificationCancelRequestParameters = RotateVerificationCancelRequestQuery & RotateVerificationCancelRouteParameters & RotateVerificationCancelRequestHeaders;
interface RotateVerificationCancelOperation<STATUS extends keyof RotateVerificationCancelResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: RotateVerificationCancelRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RotateVerificationCancelRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RotateVerificationCancelRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: RotateVerificationCancelResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/seal.type.d.ts
interface SealResponseBodies {
  204: void;
}
type SealRequestQuery = {};
type SealRouteParameters = {};
type SealRequestHeaders = {};
type SealRequestParameters = SealRequestQuery & SealRouteParameters & SealRequestHeaders;
interface SealOperation<STATUS extends keyof SealResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: SealRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: SealRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: SealRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: SealResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/seal-status-response.schema.d.ts
interface SealStatusResponse {
  build_date?: string;
  cluster_id?: string;
  cluster_name?: string;
  initialized?: boolean;
  migration?: boolean;
  n?: number;
  nonce?: string;
  progress?: number;
  recovery_seal?: boolean;
  sealed?: boolean;
  storage_type?: string;
  t?: number;
  type?: string;
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/seal-status.type.d.ts
interface SealStatusResponseBodies {
  200: SealStatusResponse;
}
type SealStatusRequestQuery = {};
type SealStatusRouteParameters = {};
type SealStatusRequestHeaders = {};
type SealStatusRequestParameters = SealStatusRequestQuery & SealStatusRouteParameters & SealStatusRequestHeaders;
interface SealStatusOperation<STATUS extends keyof SealStatusResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: SealStatusRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: SealStatusRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: SealStatusRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: SealStatusResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/step-down-leader.type.d.ts
interface StepDownLeaderResponseBodies {
  204: void;
}
type StepDownLeaderRequestQuery = {};
type StepDownLeaderRouteParameters = {};
type StepDownLeaderRequestHeaders = {};
type StepDownLeaderRequestParameters = StepDownLeaderRequestQuery & StepDownLeaderRouteParameters & StepDownLeaderRequestHeaders;
interface StepDownLeaderOperation<STATUS extends keyof StepDownLeaderResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: StepDownLeaderRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: StepDownLeaderRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: StepDownLeaderRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: StepDownLeaderResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-hash-request.schema.d.ts
interface GenerateHashRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "hex".
   */
  format?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * Algorithm to use (POST URL parameter)
   */
  urlalgorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-hash-response.schema.d.ts
interface GenerateHashResponse {
  sum?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-hash.type.d.ts
interface GenerateHashResponseBodies {
  200: GenerateHashResponse;
}
interface GenerateHashRequestBodies {
  'application/json': GenerateHashRequest;
}
type GenerateHashRequestQuery = {};
type GenerateHashRouteParameters = {};
type GenerateHashRequestHeaders = {};
interface GenerateHashParameterBodies {
  'application/json': GenerateHashRequest & {
    [key: string]: any;
  };
}
type GenerateHashRequestParameters = GenerateHashRequestQuery & GenerateHashRouteParameters & GenerateHashRequestHeaders & GenerateHashRequestBodies['application/json'];
interface GenerateHashOperation<STATUS extends keyof GenerateHashResponseBodies, CONTENT_TYPE extends keyof GenerateHashParameterBodies> extends KeqOperation {
  requestParams: GenerateHashRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateHashRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateHashRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateHashParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateHashResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-hash-with-algorithm-request.schema.d.ts
interface GenerateHashWithAlgorithmRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "hex".
   */
  format?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-hash-with-algorithm-response.schema.d.ts
interface GenerateHashWithAlgorithmResponse {
  sum?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-hash-with-algorithm.type.d.ts
interface GenerateHashWithAlgorithmResponseBodies {
  200: GenerateHashWithAlgorithmResponse;
}
interface GenerateHashWithAlgorithmRequestBodies {
  'application/json': GenerateHashWithAlgorithmRequest;
}
type GenerateHashWithAlgorithmRequestQuery = {};
type GenerateHashWithAlgorithmRouteParameters = {};
type GenerateHashWithAlgorithmRequestHeaders = {};
interface GenerateHashWithAlgorithmParameterBodies {
  'application/json': GenerateHashWithAlgorithmRequest & {
    [key: string]: any;
  };
}
type GenerateHashWithAlgorithmRequestParameters = GenerateHashWithAlgorithmRequestQuery & GenerateHashWithAlgorithmRouteParameters & GenerateHashWithAlgorithmRequestHeaders & GenerateHashWithAlgorithmRequestBodies['application/json'];
interface GenerateHashWithAlgorithmOperation<STATUS extends keyof GenerateHashWithAlgorithmResponseBodies, CONTENT_TYPE extends keyof GenerateHashWithAlgorithmParameterBodies> extends KeqOperation {
  requestParams: GenerateHashWithAlgorithmRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateHashWithAlgorithmRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateHashWithAlgorithmRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateHashWithAlgorithmParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateHashWithAlgorithmResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-request.schema.d.ts
interface GenerateRandomRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * Which system to source random data from, ether "platform", "seal", or "all".
   */
  source?: string;
  /**
   * The number of bytes to generate (POST URL parameter)
   */
  urlbytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-response.schema.d.ts
interface GenerateRandomResponse {
  random_bytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-random.type.d.ts
interface GenerateRandomResponseBodies {
  200: GenerateRandomResponse;
}
interface GenerateRandomRequestBodies {
  'application/json': GenerateRandomRequest;
}
type GenerateRandomRequestQuery = {};
type GenerateRandomRouteParameters = {};
type GenerateRandomRequestHeaders = {};
interface GenerateRandomParameterBodies {
  'application/json': GenerateRandomRequest & {
    [key: string]: any;
  };
}
type GenerateRandomRequestParameters = GenerateRandomRequestQuery & GenerateRandomRouteParameters & GenerateRandomRequestHeaders & GenerateRandomRequestBodies['application/json'];
interface GenerateRandomOperation<STATUS extends keyof GenerateRandomResponseBodies, CONTENT_TYPE extends keyof GenerateRandomParameterBodies> extends KeqOperation {
  requestParams: GenerateRandomRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateRandomRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateRandomRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateRandomParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateRandomResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-source-request.schema.d.ts
interface GenerateRandomWithSourceRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * The number of bytes to generate (POST URL parameter)
   */
  urlbytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-source-response.schema.d.ts
interface GenerateRandomWithSourceResponse {
  random_bytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-random-with-source.type.d.ts
interface GenerateRandomWithSourceResponseBodies {
  200: GenerateRandomWithSourceResponse;
}
interface GenerateRandomWithSourceRequestBodies {
  'application/json': GenerateRandomWithSourceRequest;
}
type GenerateRandomWithSourceRequestQuery = {};
type GenerateRandomWithSourceRouteParameters = {};
type GenerateRandomWithSourceRequestHeaders = {};
interface GenerateRandomWithSourceParameterBodies {
  'application/json': GenerateRandomWithSourceRequest & {
    [key: string]: any;
  };
}
type GenerateRandomWithSourceRequestParameters = GenerateRandomWithSourceRequestQuery & GenerateRandomWithSourceRouteParameters & GenerateRandomWithSourceRequestHeaders & GenerateRandomWithSourceRequestBodies['application/json'];
interface GenerateRandomWithSourceOperation<STATUS extends keyof GenerateRandomWithSourceResponseBodies, CONTENT_TYPE extends keyof GenerateRandomWithSourceParameterBodies> extends KeqOperation {
  requestParams: GenerateRandomWithSourceRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateRandomWithSourceRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateRandomWithSourceRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateRandomWithSourceParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateRandomWithSourceResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-source-and-bytes-request.schema.d.ts
interface GenerateRandomWithSourceAndBytesRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-source-and-bytes-response.schema.d.ts
interface GenerateRandomWithSourceAndBytesResponse {
  random_bytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-random-with-source-and-bytes.type.d.ts
interface GenerateRandomWithSourceAndBytesResponseBodies {
  200: GenerateRandomWithSourceAndBytesResponse;
}
interface GenerateRandomWithSourceAndBytesRequestBodies {
  'application/json': GenerateRandomWithSourceAndBytesRequest;
}
type GenerateRandomWithSourceAndBytesRequestQuery = {};
type GenerateRandomWithSourceAndBytesRouteParameters = {};
type GenerateRandomWithSourceAndBytesRequestHeaders = {};
interface GenerateRandomWithSourceAndBytesParameterBodies {
  'application/json': GenerateRandomWithSourceAndBytesRequest & {
    [key: string]: any;
  };
}
type GenerateRandomWithSourceAndBytesRequestParameters = GenerateRandomWithSourceAndBytesRequestQuery & GenerateRandomWithSourceAndBytesRouteParameters & GenerateRandomWithSourceAndBytesRequestHeaders & GenerateRandomWithSourceAndBytesRequestBodies['application/json'];
interface GenerateRandomWithSourceAndBytesOperation<STATUS extends keyof GenerateRandomWithSourceAndBytesResponseBodies, CONTENT_TYPE extends keyof GenerateRandomWithSourceAndBytesParameterBodies> extends KeqOperation {
  requestParams: GenerateRandomWithSourceAndBytesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateRandomWithSourceAndBytesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateRandomWithSourceAndBytesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateRandomWithSourceAndBytesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateRandomWithSourceAndBytesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-bytes-request.schema.d.ts
interface GenerateRandomWithBytesRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * Which system to source random data from, ether "platform", "seal", or "all".
   */
  source?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/generate-random-with-bytes-response.schema.d.ts
interface GenerateRandomWithBytesResponse {
  random_bytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/generate-random-with-bytes.type.d.ts
interface GenerateRandomWithBytesResponseBodies {
  200: GenerateRandomWithBytesResponse;
}
interface GenerateRandomWithBytesRequestBodies {
  'application/json': GenerateRandomWithBytesRequest;
}
type GenerateRandomWithBytesRequestQuery = {};
type GenerateRandomWithBytesRouteParameters = {};
type GenerateRandomWithBytesRequestHeaders = {};
interface GenerateRandomWithBytesParameterBodies {
  'application/json': GenerateRandomWithBytesRequest & {
    [key: string]: any;
  };
}
type GenerateRandomWithBytesRequestParameters = GenerateRandomWithBytesRequestQuery & GenerateRandomWithBytesRouteParameters & GenerateRandomWithBytesRequestHeaders & GenerateRandomWithBytesRequestBodies['application/json'];
interface GenerateRandomWithBytesOperation<STATUS extends keyof GenerateRandomWithBytesResponseBodies, CONTENT_TYPE extends keyof GenerateRandomWithBytesParameterBodies> extends KeqOperation {
  requestParams: GenerateRandomWithBytesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GenerateRandomWithBytesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GenerateRandomWithBytesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GenerateRandomWithBytesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GenerateRandomWithBytesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/unseal-request.schema.d.ts
interface UnsealRequest {
  /**
   * Specifies a single unseal key share. This is required unless reset is true.
   */
  key?: string;
  /**
   * Specifies if previously-provided unseal keys are discarded and the unseal process is reset.
   */
  reset?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/unseal-response.schema.d.ts
interface UnsealResponse {
  build_date?: string;
  cluster_id?: string;
  cluster_name?: string;
  initialized?: boolean;
  migration?: boolean;
  n?: number;
  nonce?: string;
  progress?: number;
  recovery_seal?: boolean;
  sealed?: boolean;
  storage_type?: string;
  t?: number;
  type?: string;
  version?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/unseal.type.d.ts
interface UnsealResponseBodies {
  200: UnsealResponse;
}
interface UnsealRequestBodies {
  'application/json': UnsealRequest;
}
type UnsealRequestQuery = {};
type UnsealRouteParameters = {};
type UnsealRequestHeaders = {};
interface UnsealParameterBodies {
  'application/json': UnsealRequest & {
    [key: string]: any;
  };
}
type UnsealRequestParameters = UnsealRequestQuery & UnsealRouteParameters & UnsealRequestHeaders & UnsealRequestBodies['application/json'];
interface UnsealOperation<STATUS extends keyof UnsealResponseBodies, CONTENT_TYPE extends keyof UnsealParameterBodies> extends KeqOperation {
  requestParams: UnsealRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UnsealRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UnsealRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UnsealParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UnsealResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/read-wrapping-properties-request.schema.d.ts
interface ReadWrappingPropertiesRequest {
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/read-wrapping-properties-response.schema.d.ts
interface ReadWrappingPropertiesResponse {
  creation_path?: string;
  /**
   * @format date-time
   */
  creation_time?: string;
  /**
   * @format seconds
   */
  creation_ttl?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/read-wrapping-properties.type.d.ts
interface ReadWrappingPropertiesResponseBodies {
  200: ReadWrappingPropertiesResponse;
}
interface ReadWrappingPropertiesRequestBodies {
  'application/json': ReadWrappingPropertiesRequest;
}
type ReadWrappingPropertiesRequestQuery = {};
type ReadWrappingPropertiesRouteParameters = {};
type ReadWrappingPropertiesRequestHeaders = {};
interface ReadWrappingPropertiesParameterBodies {
  'application/json': ReadWrappingPropertiesRequest & {
    [key: string]: any;
  };
}
type ReadWrappingPropertiesRequestParameters = ReadWrappingPropertiesRequestQuery & ReadWrappingPropertiesRouteParameters & ReadWrappingPropertiesRequestHeaders & ReadWrappingPropertiesRequestBodies['application/json'];
interface ReadWrappingPropertiesOperation<STATUS extends keyof ReadWrappingPropertiesResponseBodies, CONTENT_TYPE extends keyof ReadWrappingPropertiesParameterBodies> extends KeqOperation {
  requestParams: ReadWrappingPropertiesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: ReadWrappingPropertiesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: ReadWrappingPropertiesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: ReadWrappingPropertiesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: ReadWrappingPropertiesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/rewrap-request.schema.d.ts
interface RewrapRequest {
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/rewrap.type.d.ts
interface RewrapResponseBodies {
  200: void;
}
interface RewrapRequestBodies {
  'application/json': RewrapRequest;
}
type RewrapRequestQuery = {};
type RewrapRouteParameters = {};
type RewrapRequestHeaders = {};
interface RewrapParameterBodies {
  'application/json': RewrapRequest & {
    [key: string]: any;
  };
}
type RewrapRequestParameters = RewrapRequestQuery & RewrapRouteParameters & RewrapRequestHeaders & RewrapRequestBodies['application/json'];
interface RewrapOperation<STATUS extends keyof RewrapResponseBodies, CONTENT_TYPE extends keyof RewrapParameterBodies> extends KeqOperation {
  requestParams: RewrapRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: RewrapRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: RewrapRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: RewrapParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: RewrapResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/unwrap-request.schema.d.ts
interface UnwrapRequest {
  token?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/unwrap.type.d.ts
interface UnwrapResponseBodies {
  200: void;
  204: void;
}
interface UnwrapRequestBodies {
  'application/json': UnwrapRequest;
}
type UnwrapRequestQuery = {};
type UnwrapRouteParameters = {};
type UnwrapRequestHeaders = {};
interface UnwrapParameterBodies {
  'application/json': UnwrapRequest & {
    [key: string]: any;
  };
}
type UnwrapRequestParameters = UnwrapRequestQuery & UnwrapRouteParameters & UnwrapRequestHeaders & UnwrapRequestBodies['application/json'];
interface UnwrapOperation<STATUS extends keyof UnwrapResponseBodies, CONTENT_TYPE extends keyof UnwrapParameterBodies> extends KeqOperation {
  requestParams: UnwrapRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: UnwrapRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: UnwrapRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: UnwrapParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: UnwrapResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/wrap.type.d.ts
interface WrapResponseBodies {
  200: void;
}
type WrapRequestQuery = {};
type WrapRouteParameters = {};
type WrapRequestHeaders = {};
type WrapRequestParameters = WrapRequestQuery & WrapRouteParameters & WrapRequestHeaders;
interface WrapOperation<STATUS extends keyof WrapResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: WrapRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: WrapRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: WrapRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: WrapResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-back-up-key.type.d.ts
interface TransitBackUpKeyResponseBodies {
  200: void;
}
type TransitBackUpKeyRequestQuery = {};
type TransitBackUpKeyRouteParameters = {};
type TransitBackUpKeyRequestHeaders = {};
type TransitBackUpKeyRequestParameters = TransitBackUpKeyRequestQuery & TransitBackUpKeyRouteParameters & TransitBackUpKeyRequestHeaders;
interface TransitBackUpKeyOperation<STATUS extends keyof TransitBackUpKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitBackUpKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitBackUpKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitBackUpKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitBackUpKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-byok-key.type.d.ts
interface TransitByokKeyResponseBodies {
  200: void;
}
type TransitByokKeyRequestQuery = {};
type TransitByokKeyRouteParameters = {};
type TransitByokKeyRequestHeaders = {};
type TransitByokKeyRequestParameters = TransitByokKeyRequestQuery & TransitByokKeyRouteParameters & TransitByokKeyRequestHeaders;
interface TransitByokKeyOperation<STATUS extends keyof TransitByokKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitByokKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitByokKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitByokKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitByokKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-byok-key-version.type.d.ts
interface TransitByokKeyVersionResponseBodies {
  200: void;
}
type TransitByokKeyVersionRequestQuery = {};
type TransitByokKeyVersionRouteParameters = {};
type TransitByokKeyVersionRequestHeaders = {};
type TransitByokKeyVersionRequestParameters = TransitByokKeyVersionRequestQuery & TransitByokKeyVersionRouteParameters & TransitByokKeyVersionRequestHeaders;
interface TransitByokKeyVersionOperation<STATUS extends keyof TransitByokKeyVersionResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitByokKeyVersionRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitByokKeyVersionRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitByokKeyVersionRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitByokKeyVersionResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-read-cache-configuration.type.d.ts
interface TransitReadCacheConfigurationResponseBodies {
  200: void;
}
type TransitReadCacheConfigurationRequestQuery = {};
type TransitReadCacheConfigurationRouteParameters = {};
type TransitReadCacheConfigurationRequestHeaders = {};
type TransitReadCacheConfigurationRequestParameters = TransitReadCacheConfigurationRequestQuery & TransitReadCacheConfigurationRouteParameters & TransitReadCacheConfigurationRequestHeaders;
interface TransitReadCacheConfigurationOperation<STATUS extends keyof TransitReadCacheConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitReadCacheConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitReadCacheConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitReadCacheConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitReadCacheConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-configure-cache-request.schema.d.ts
interface TransitConfigureCacheRequest {
  /**
   * Size of cache, use 0 for an unlimited cache size, defaults to 0
   */
  size?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-configure-cache.type.d.ts
interface TransitConfigureCacheResponseBodies {
  200: void;
}
interface TransitConfigureCacheRequestBodies {
  'application/json': TransitConfigureCacheRequest;
}
type TransitConfigureCacheRequestQuery = {};
type TransitConfigureCacheRouteParameters = {};
type TransitConfigureCacheRequestHeaders = {};
interface TransitConfigureCacheParameterBodies {
  'application/json': TransitConfigureCacheRequest & {
    [key: string]: any;
  };
}
type TransitConfigureCacheRequestParameters = TransitConfigureCacheRequestQuery & TransitConfigureCacheRouteParameters & TransitConfigureCacheRequestHeaders & TransitConfigureCacheRequestBodies['application/json'];
interface TransitConfigureCacheOperation<STATUS extends keyof TransitConfigureCacheResponseBodies, CONTENT_TYPE extends keyof TransitConfigureCacheParameterBodies> extends KeqOperation {
  requestParams: TransitConfigureCacheRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitConfigureCacheRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitConfigureCacheRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitConfigureCacheParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitConfigureCacheResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-read-keys-configuration.type.d.ts
interface TransitReadKeysConfigurationResponseBodies {
  200: void;
}
type TransitReadKeysConfigurationRequestQuery = {};
type TransitReadKeysConfigurationRouteParameters = {};
type TransitReadKeysConfigurationRequestHeaders = {};
type TransitReadKeysConfigurationRequestParameters = TransitReadKeysConfigurationRequestQuery & TransitReadKeysConfigurationRouteParameters & TransitReadKeysConfigurationRequestHeaders;
interface TransitReadKeysConfigurationOperation<STATUS extends keyof TransitReadKeysConfigurationResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitReadKeysConfigurationRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitReadKeysConfigurationRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitReadKeysConfigurationRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitReadKeysConfigurationResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-configure-keys-request.schema.d.ts
interface TransitConfigureKeysRequest {
  /**
   * Whether to allow automatic upserting (creation) of keys on the encrypt endpoint.
   */
  disable_upsert?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-configure-keys.type.d.ts
interface TransitConfigureKeysResponseBodies {
  200: void;
}
interface TransitConfigureKeysRequestBodies {
  'application/json': TransitConfigureKeysRequest;
}
type TransitConfigureKeysRequestQuery = {};
type TransitConfigureKeysRouteParameters = {};
type TransitConfigureKeysRequestHeaders = {};
interface TransitConfigureKeysParameterBodies {
  'application/json': TransitConfigureKeysRequest & {
    [key: string]: any;
  };
}
type TransitConfigureKeysRequestParameters = TransitConfigureKeysRequestQuery & TransitConfigureKeysRouteParameters & TransitConfigureKeysRequestHeaders & TransitConfigureKeysRequestBodies['application/json'];
interface TransitConfigureKeysOperation<STATUS extends keyof TransitConfigureKeysResponseBodies, CONTENT_TYPE extends keyof TransitConfigureKeysParameterBodies> extends KeqOperation {
  requestParams: TransitConfigureKeysRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitConfigureKeysRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitConfigureKeysRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitConfigureKeysParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitConfigureKeysResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-data-key-request.schema.d.ts
interface TransitGenerateDataKeyRequest {
  /**
   * When using an AEAD cipher mode, such as AES-GCM, this parameter allows passing associated data (AD/AAD) into the encryption function; this data must be passed on subsequent decryption requests but can be transited in plaintext. On successful decryption, both the ciphertext and the associated data are attested not to have been tampered with.
   */
  associated_data?: string;
  /**
   * Number of bits for the key; currently 128, 256, and 512 bits are supported. Defaults to 256.
   */
  bits?: number;
  /**
   * Context for key derivation. Required for derived keys.
   */
  context?: string;
  /**
   * The version of the OpenBao key to use for encryption of the data key. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-data-key.type.d.ts
interface TransitGenerateDataKeyResponseBodies {
  200: void;
}
interface TransitGenerateDataKeyRequestBodies {
  'application/json': TransitGenerateDataKeyRequest;
}
type TransitGenerateDataKeyRequestQuery = {};
type TransitGenerateDataKeyRouteParameters = {};
type TransitGenerateDataKeyRequestHeaders = {};
interface TransitGenerateDataKeyParameterBodies {
  'application/json': TransitGenerateDataKeyRequest & {
    [key: string]: any;
  };
}
type TransitGenerateDataKeyRequestParameters = TransitGenerateDataKeyRequestQuery & TransitGenerateDataKeyRouteParameters & TransitGenerateDataKeyRequestHeaders & TransitGenerateDataKeyRequestBodies['application/json'];
interface TransitGenerateDataKeyOperation<STATUS extends keyof TransitGenerateDataKeyResponseBodies, CONTENT_TYPE extends keyof TransitGenerateDataKeyParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateDataKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateDataKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateDataKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateDataKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateDataKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-decrypt-request.schema.d.ts
interface TransitDecryptRequest {
  /**
   * When using an AEAD cipher mode, such as AES-GCM, this parameter allows passing associated data (AD/AAD) into the encryption function; this data must be passed on subsequent decryption requests but can be transited in plaintext. On successful decryption, both the ciphertext and the associated data are attested not to have been tampered with.
   */
  associated_data?: string;
  /**
   * Specifies a list of items to be decrypted in a single batch. When this parameter is set, if the parameters 'ciphertext' and 'context' are also set, they will be ignored. Any batch output will preserve the order of the batch input.
   */
  batch_input?: Record<string, never>[];
  /**
   * The ciphertext to decrypt, provided as returned by encrypt.
   */
  ciphertext?: string;
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled.
   */
  context?: string;
  /**
   * Ordinarily, if a batch item fails to decrypt due to a bad input, but other batch items succeed, the HTTP response code is 400 (Bad Request). Some applications may want to treat partial failures differently. Providing the parameter returns the given response code integer instead of a 400 in this case. If all values fail HTTP 400 is still returned.
   */
  partial_failure_response_code?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-decrypt.type.d.ts
interface TransitDecryptResponseBodies {
  200: void;
}
interface TransitDecryptRequestBodies {
  'application/json': TransitDecryptRequest;
}
type TransitDecryptRequestQuery = {};
type TransitDecryptRouteParameters = {};
type TransitDecryptRequestHeaders = {};
interface TransitDecryptParameterBodies {
  'application/json': TransitDecryptRequest & {
    [key: string]: any;
  };
}
type TransitDecryptRequestParameters = TransitDecryptRequestQuery & TransitDecryptRouteParameters & TransitDecryptRequestHeaders & TransitDecryptRequestBodies['application/json'];
interface TransitDecryptOperation<STATUS extends keyof TransitDecryptResponseBodies, CONTENT_TYPE extends keyof TransitDecryptParameterBodies> extends KeqOperation {
  requestParams: TransitDecryptRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitDecryptRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitDecryptRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitDecryptParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitDecryptResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-derive-key-request.schema.d.ts
interface TransitDeriveKeyRequest {
  /**
   * Name of the base key to use for derivation (own private key for ECDH)
   */
  base_key_name?: string;
  /**
   * The version of the base key to use for derivation. Must be 0 (for latest) or a value greater than or equal to the min_derivation_version configured on the key.
   */
  base_key_version?: number;
  /**
   * The type of the output derived key. Currently, "aes128-gcm96" , "aes256-gcm96", "chacha20-poly1305", "xchacha20-poly1305" are supported. Defaults to "aes256-gcm96".
   */
  derived_key_type?: string;
  /**
   * Key derivation algorithm to use. Valid values are: * ecdh Defaults to "ecdh".
   */
  key_derivation_algorithm?: string;
  /**
   * The pem-encoded other party's ECC public key
   */
  peer_public_key?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-derive-key.type.d.ts
interface TransitDeriveKeyResponseBodies {
  200: void;
}
interface TransitDeriveKeyRequestBodies {
  'application/json': TransitDeriveKeyRequest;
}
type TransitDeriveKeyRequestQuery = {};
type TransitDeriveKeyRouteParameters = {};
type TransitDeriveKeyRequestHeaders = {};
interface TransitDeriveKeyParameterBodies {
  'application/json': TransitDeriveKeyRequest & {
    [key: string]: any;
  };
}
type TransitDeriveKeyRequestParameters = TransitDeriveKeyRequestQuery & TransitDeriveKeyRouteParameters & TransitDeriveKeyRequestHeaders & TransitDeriveKeyRequestBodies['application/json'];
interface TransitDeriveKeyOperation<STATUS extends keyof TransitDeriveKeyResponseBodies, CONTENT_TYPE extends keyof TransitDeriveKeyParameterBodies> extends KeqOperation {
  requestParams: TransitDeriveKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitDeriveKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitDeriveKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitDeriveKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitDeriveKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-encrypt-request.schema.d.ts
interface TransitEncryptRequest {
  /**
   * When using an AEAD cipher mode, such as AES-GCM, this parameter allows passing associated data (AD/AAD) into the encryption function; this data must be passed on subsequent decryption requests but can be transited in plaintext. On successful decryption, both the ciphertext and the associated data are attested not to have been tampered with.
   */
  associated_data?: string;
  /**
   * Specifies a list of items to be encrypted in a single batch. When this parameter is set, if the parameters 'plaintext' and 'context' are also set, they will be ignored. Any batch output will preserve the order of the batch input.
   */
  batch_input?: Record<string, never>[];
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled
   */
  context?: string;
  /**
   * This parameter will only be used when a key is expected to be created. Whether to support convergent encryption. This is only supported when using a key with key derivation enabled and will require all requests to carry both a context and 96-bit (12-byte) nonce. The given nonce will be used in place of a randomly generated nonce. As a result, when the same context and nonce are supplied, the same ciphertext is generated. It is *very important* when using this mode that you ensure that all nonces are unique for a given context. Failing to do so will severely impact the ciphertext's security.
   */
  convergent_encryption?: boolean;
  /**
   * The version of the key to use for encryption. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
  /**
   * Ordinarily, if a batch item fails to encrypt due to a bad input, but other batch items succeed, the HTTP response code is 400 (Bad Request). Some applications may want to treat partial failures differently. Providing the parameter returns the given response code integer instead of a 400 in this case. If all values fail HTTP 400 is still returned.
   */
  partial_failure_response_code?: number;
  /**
   * Base64 encoded plaintext value to be encrypted
   */
  plaintext?: string;
  /**
   * This parameter is required when encryption key is expected to be created. When performing an upsert operation, the type of key to create. Currently, "aes128-gcm96" (symmetric) and "aes256-gcm96" (symmetric) are the only types supported. Defaults to "aes256-gcm96".
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-encrypt.type.d.ts
interface TransitEncryptResponseBodies {
  200: void;
}
interface TransitEncryptRequestBodies {
  'application/json': TransitEncryptRequest;
}
type TransitEncryptRequestQuery = {};
type TransitEncryptRouteParameters = {};
type TransitEncryptRequestHeaders = {};
interface TransitEncryptParameterBodies {
  'application/json': TransitEncryptRequest & {
    [key: string]: any;
  };
}
type TransitEncryptRequestParameters = TransitEncryptRequestQuery & TransitEncryptRouteParameters & TransitEncryptRequestHeaders & TransitEncryptRequestBodies['application/json'];
interface TransitEncryptOperation<STATUS extends keyof TransitEncryptResponseBodies, CONTENT_TYPE extends keyof TransitEncryptParameterBodies> extends KeqOperation {
  requestParams: TransitEncryptRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitEncryptRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitEncryptRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitEncryptParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitEncryptResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-export-key.type.d.ts
interface TransitExportKeyResponseBodies {
  200: void;
}
type TransitExportKeyRequestQuery = {};
type TransitExportKeyRouteParameters = {};
type TransitExportKeyRequestHeaders = {};
type TransitExportKeyRequestParameters = TransitExportKeyRequestQuery & TransitExportKeyRouteParameters & TransitExportKeyRequestHeaders;
interface TransitExportKeyOperation<STATUS extends keyof TransitExportKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitExportKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitExportKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitExportKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitExportKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-export-key-version.type.d.ts
interface TransitExportKeyVersionResponseBodies {
  200: void;
}
type TransitExportKeyVersionRequestQuery = {};
type TransitExportKeyVersionRouteParameters = {};
type TransitExportKeyVersionRequestHeaders = {};
type TransitExportKeyVersionRequestParameters = TransitExportKeyVersionRequestQuery & TransitExportKeyVersionRouteParameters & TransitExportKeyVersionRequestHeaders;
interface TransitExportKeyVersionOperation<STATUS extends keyof TransitExportKeyVersionResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitExportKeyVersionRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitExportKeyVersionRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitExportKeyVersionRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitExportKeyVersionResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-hash-request.schema.d.ts
interface TransitHashRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "hex".
   */
  format?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * Algorithm to use (POST URL parameter)
   */
  urlalgorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-hash.type.d.ts
interface TransitHashResponseBodies {
  200: void;
}
interface TransitHashRequestBodies {
  'application/json': TransitHashRequest;
}
type TransitHashRequestQuery = {};
type TransitHashRouteParameters = {};
type TransitHashRequestHeaders = {};
interface TransitHashParameterBodies {
  'application/json': TransitHashRequest & {
    [key: string]: any;
  };
}
type TransitHashRequestParameters = TransitHashRequestQuery & TransitHashRouteParameters & TransitHashRequestHeaders & TransitHashRequestBodies['application/json'];
interface TransitHashOperation<STATUS extends keyof TransitHashResponseBodies, CONTENT_TYPE extends keyof TransitHashParameterBodies> extends KeqOperation {
  requestParams: TransitHashRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitHashRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitHashRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitHashParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitHashResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-hash-with-algorithm-request.schema.d.ts
interface TransitHashWithAlgorithmRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "hex".
   */
  format?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-hash-with-algorithm.type.d.ts
interface TransitHashWithAlgorithmResponseBodies {
  200: void;
}
interface TransitHashWithAlgorithmRequestBodies {
  'application/json': TransitHashWithAlgorithmRequest;
}
type TransitHashWithAlgorithmRequestQuery = {};
type TransitHashWithAlgorithmRouteParameters = {};
type TransitHashWithAlgorithmRequestHeaders = {};
interface TransitHashWithAlgorithmParameterBodies {
  'application/json': TransitHashWithAlgorithmRequest & {
    [key: string]: any;
  };
}
type TransitHashWithAlgorithmRequestParameters = TransitHashWithAlgorithmRequestQuery & TransitHashWithAlgorithmRouteParameters & TransitHashWithAlgorithmRequestHeaders & TransitHashWithAlgorithmRequestBodies['application/json'];
interface TransitHashWithAlgorithmOperation<STATUS extends keyof TransitHashWithAlgorithmResponseBodies, CONTENT_TYPE extends keyof TransitHashWithAlgorithmParameterBodies> extends KeqOperation {
  requestParams: TransitHashWithAlgorithmRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitHashWithAlgorithmRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitHashWithAlgorithmRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitHashWithAlgorithmParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitHashWithAlgorithmResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-hmac-request.schema.d.ts
interface TransitGenerateHmacRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Specifies a list of items to be processed in a single batch. When this parameter is set, if the parameter 'input' is also set, it will be ignored. Any batch output will preserve the order of the batch input.
   */
  batch_input?: Record<string, never>[];
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * The version of the key to use for generating the HMAC. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
  /**
   * Algorithm to use (POST URL parameter)
   */
  urlalgorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-hmac.type.d.ts
interface TransitGenerateHmacResponseBodies {
  200: void;
}
interface TransitGenerateHmacRequestBodies {
  'application/json': TransitGenerateHmacRequest;
}
type TransitGenerateHmacRequestQuery = {};
type TransitGenerateHmacRouteParameters = {};
type TransitGenerateHmacRequestHeaders = {};
interface TransitGenerateHmacParameterBodies {
  'application/json': TransitGenerateHmacRequest & {
    [key: string]: any;
  };
}
type TransitGenerateHmacRequestParameters = TransitGenerateHmacRequestQuery & TransitGenerateHmacRouteParameters & TransitGenerateHmacRequestHeaders & TransitGenerateHmacRequestBodies['application/json'];
interface TransitGenerateHmacOperation<STATUS extends keyof TransitGenerateHmacResponseBodies, CONTENT_TYPE extends keyof TransitGenerateHmacParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateHmacRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateHmacRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateHmacRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateHmacParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateHmacResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-hmac-with-algorithm-request.schema.d.ts
interface TransitGenerateHmacWithAlgorithmRequest {
  /**
   * Algorithm to use (POST body parameter). Valid values are: * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 Defaults to "sha2-256".
   */
  algorithm?: string;
  /**
   * Specifies a list of items to be processed in a single batch. When this parameter is set, if the parameter 'input' is also set, it will be ignored. Any batch output will preserve the order of the batch input.
   */
  batch_input?: Record<string, never>[];
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * The version of the key to use for generating the HMAC. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-hmac-with-algorithm.type.d.ts
interface TransitGenerateHmacWithAlgorithmResponseBodies {
  200: void;
}
interface TransitGenerateHmacWithAlgorithmRequestBodies {
  'application/json': TransitGenerateHmacWithAlgorithmRequest;
}
type TransitGenerateHmacWithAlgorithmRequestQuery = {};
type TransitGenerateHmacWithAlgorithmRouteParameters = {};
type TransitGenerateHmacWithAlgorithmRequestHeaders = {};
interface TransitGenerateHmacWithAlgorithmParameterBodies {
  'application/json': TransitGenerateHmacWithAlgorithmRequest & {
    [key: string]: any;
  };
}
type TransitGenerateHmacWithAlgorithmRequestParameters = TransitGenerateHmacWithAlgorithmRequestQuery & TransitGenerateHmacWithAlgorithmRouteParameters & TransitGenerateHmacWithAlgorithmRequestHeaders & TransitGenerateHmacWithAlgorithmRequestBodies['application/json'];
interface TransitGenerateHmacWithAlgorithmOperation<STATUS extends keyof TransitGenerateHmacWithAlgorithmResponseBodies, CONTENT_TYPE extends keyof TransitGenerateHmacWithAlgorithmParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateHmacWithAlgorithmRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateHmacWithAlgorithmRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateHmacWithAlgorithmRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateHmacWithAlgorithmParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateHmacWithAlgorithmResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-list-keys.type.d.ts
interface TransitListKeysResponseBodies {
  200: void;
}
type TransitListKeysRequestQuery = {
  list: ('true');
};
type TransitListKeysRouteParameters = {};
type TransitListKeysRequestHeaders = {};
type TransitListKeysRequestParameters = TransitListKeysRequestQuery & TransitListKeysRouteParameters & TransitListKeysRequestHeaders;
interface TransitListKeysOperation<STATUS extends keyof TransitListKeysResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitListKeysRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitListKeysRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitListKeysRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitListKeysResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-read-key.type.d.ts
interface TransitReadKeyResponseBodies {
  200: void;
}
type TransitReadKeyRequestQuery = {};
type TransitReadKeyRouteParameters = {};
type TransitReadKeyRequestHeaders = {};
type TransitReadKeyRequestParameters = TransitReadKeyRequestQuery & TransitReadKeyRouteParameters & TransitReadKeyRequestHeaders;
interface TransitReadKeyOperation<STATUS extends keyof TransitReadKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitReadKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitReadKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitReadKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitReadKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-create-key-request.schema.d.ts
interface TransitCreateKeyRequest {
  /**
   * Enables taking a backup of the named key in plaintext format. Once set, this cannot be disabled.
   */
  allow_plaintext_backup?: boolean;
  /**
   * Amount of time the key should live before being automatically rotated. A value of 0 (default) disables automatic rotation for the key.
   * @format seconds
   */
  auto_rotate_period?: number;
  /**
   * Base64 encoded context for key derivation. When reading a key with key derivation enabled, if the key type supports public keys, this will return the public key for the given context.
   */
  context?: string;
  /**
   * Whether to support convergent encryption. This is only supported when using a key with key derivation enabled and will require all requests to carry both a context and 96-bit (12-byte) nonce. The given nonce will be used in place of a randomly generated nonce. As a result, when the same context and nonce are supplied, the same ciphertext is generated. It is *very important* when using this mode that you ensure that all nonces are unique for a given context. Failing to do so will severely impact the ciphertext's security.
   */
  convergent_encryption?: boolean;
  /**
   * Enables key derivation mode. This allows for per-transaction unique keys for encryption operations.
   */
  derived?: boolean;
  /**
   * Enables keys to be exportable. This allows for all the valid keys in the key ring to be exported.
   */
  exportable?: boolean;
  /**
   * The key size in bytes for the algorithm. Only applies to HMAC and must be no fewer than 32 bytes and no more than 512
   */
  key_size?: number;
  /**
   * The type of key to create. Currently, "aes128-gcm96" (symmetric), "aes256-gcm96" (symmetric), "ecdsa-p256" (asymmetric), "ecdsa-p384" (asymmetric), "ecdsa-p521" (asymmetric), "ed25519" (asymmetric), "rsa-2048" (asymmetric), "rsa-3072" (asymmetric), "rsa-4096" (asymmetric) are supported. Defaults to "aes256-gcm96".
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-create-key.type.d.ts
interface TransitCreateKeyResponseBodies {
  200: void;
}
interface TransitCreateKeyRequestBodies {
  'application/json': TransitCreateKeyRequest;
}
type TransitCreateKeyRequestQuery = {};
type TransitCreateKeyRouteParameters = {};
type TransitCreateKeyRequestHeaders = {};
interface TransitCreateKeyParameterBodies {
  'application/json': TransitCreateKeyRequest & {
    [key: string]: any;
  };
}
type TransitCreateKeyRequestParameters = TransitCreateKeyRequestQuery & TransitCreateKeyRouteParameters & TransitCreateKeyRequestHeaders & TransitCreateKeyRequestBodies['application/json'];
interface TransitCreateKeyOperation<STATUS extends keyof TransitCreateKeyResponseBodies, CONTENT_TYPE extends keyof TransitCreateKeyParameterBodies> extends KeqOperation {
  requestParams: TransitCreateKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitCreateKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitCreateKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitCreateKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitCreateKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-delete-key.type.d.ts
interface TransitDeleteKeyResponseBodies {
  204: void;
}
type TransitDeleteKeyRequestQuery = {};
type TransitDeleteKeyRouteParameters = {};
type TransitDeleteKeyRequestHeaders = {};
type TransitDeleteKeyRequestParameters = TransitDeleteKeyRequestQuery & TransitDeleteKeyRouteParameters & TransitDeleteKeyRequestHeaders;
interface TransitDeleteKeyOperation<STATUS extends keyof TransitDeleteKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitDeleteKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitDeleteKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitDeleteKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitDeleteKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-configure-key-request.schema.d.ts
interface TransitConfigureKeyRequest {
  /**
   * Enables taking a backup of the named key in plaintext format. Once set, this cannot be disabled.
   */
  allow_plaintext_backup?: boolean;
  /**
   * Amount of time the key should live before being automatically rotated. A value of 0 disables automatic rotation for the key.
   * @format seconds
   */
  auto_rotate_period?: number;
  /**
   * Whether to allow deletion of the key
   */
  deletion_allowed?: boolean;
  /**
   * Enables export of the key. Once set, this cannot be disabled.
   */
  exportable?: boolean;
  /**
   * If set, the minimum version of the key allowed to be decrypted. For signing keys, the minimum version allowed to be used for verification.
   */
  min_decryption_version?: number;
  /**
   * If set, the minimum version of the key allowed to be used for encryption; or for signing keys, to be used for signing. If set to zero, only the latest version of the key is allowed.
   */
  min_encryption_version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-configure-key.type.d.ts
interface TransitConfigureKeyResponseBodies {
  200: void;
}
interface TransitConfigureKeyRequestBodies {
  'application/json': TransitConfigureKeyRequest;
}
type TransitConfigureKeyRequestQuery = {};
type TransitConfigureKeyRouteParameters = {};
type TransitConfigureKeyRequestHeaders = {};
interface TransitConfigureKeyParameterBodies {
  'application/json': TransitConfigureKeyRequest & {
    [key: string]: any;
  };
}
type TransitConfigureKeyRequestParameters = TransitConfigureKeyRequestQuery & TransitConfigureKeyRouteParameters & TransitConfigureKeyRequestHeaders & TransitConfigureKeyRequestBodies['application/json'];
interface TransitConfigureKeyOperation<STATUS extends keyof TransitConfigureKeyResponseBodies, CONTENT_TYPE extends keyof TransitConfigureKeyParameterBodies> extends KeqOperation {
  requestParams: TransitConfigureKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitConfigureKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitConfigureKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitConfigureKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitConfigureKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/get-csr-request.schema.d.ts
interface GetCsrRequest {
  /**
   * Optional PEM-encoded CSR template to use as the basis for the new CSR signed by this key. If not set, an empty CSR is used.
   */
  csr?: string;
  /**
   * Version of the key to use for signing. If the version is set to `latest`, or is not set, the current key will be returned
   */
  version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/get-csr.type.d.ts
interface GetCsrResponseBodies {
  200: void;
}
interface GetCsrRequestBodies {
  'application/json': GetCsrRequest;
}
type GetCsrRequestQuery = {};
type GetCsrRouteParameters = {};
type GetCsrRequestHeaders = {};
interface GetCsrParameterBodies {
  'application/json': GetCsrRequest & {
    [key: string]: any;
  };
}
type GetCsrRequestParameters = GetCsrRequestQuery & GetCsrRouteParameters & GetCsrRequestHeaders & GetCsrRequestBodies['application/json'];
interface GetCsrOperation<STATUS extends keyof GetCsrResponseBodies, CONTENT_TYPE extends keyof GetCsrParameterBodies> extends KeqOperation {
  requestParams: GetCsrRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: GetCsrRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: GetCsrRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: GetCsrParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: GetCsrResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-import-key-request.schema.d.ts
interface TransitImportKeyRequest {
  /**
   * Enables taking a backup of the named key in plaintext format. Once set, this cannot be disabled.
   */
  allow_plaintext_backup?: boolean;
  /**
   * True if the imported key may be rotated within OpenBao; false otherwise.
   */
  allow_rotation?: boolean;
  /**
   * Amount of time the key should live before being automatically rotated. A value of 0 (default) disables automatic rotation for the key.
   * @format seconds
   */
  auto_rotate_period?: number;
  /**
   * The base64-encoded ciphertext of the keys. The AES key should be encrypted using OAEP with the wrapping key and then concatenated with the import key, wrapped by the AES key.
   */
  ciphertext?: string;
  /**
   * Base64 encoded context for key derivation. When reading a key with key derivation enabled, if the key type supports public keys, this will return the public key for the given context.
   */
  context?: string;
  /**
   * Enables key derivation mode. This allows for per-transaction unique keys for encryption operations.
   */
  derived?: boolean;
  /**
   * Enables keys to be exportable. This allows for all the valid keys in the key ring to be exported.
   */
  exportable?: boolean;
  /**
   * The hash function used as a random oracle in the OAEP wrapping of the user-generated, ephemeral AES key. Can be one of "SHA1", "SHA224", "SHA256" (default), "SHA384", or "SHA512"
   */
  hash_function?: string;
  /**
   * The plaintext PEM public key to be imported. If "ciphertext" is set, this field is ignored.
   */
  public_key?: string;
  /**
   * The type of key being imported. Currently, "aes128-gcm96" (symmetric), "aes256-gcm96" (symmetric), "ecdsa-p256" (asymmetric), "ecdsa-p384" (asymmetric), "ecdsa-p521" (asymmetric), "ed25519" (asymmetric), "rsa-2048" (asymmetric), "rsa-3072" (asymmetric), "rsa-4096" (asymmetric) are supported. Defaults to "aes256-gcm96".
   */
  type?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-import-key.type.d.ts
interface TransitImportKeyResponseBodies {
  200: void;
}
interface TransitImportKeyRequestBodies {
  'application/json': TransitImportKeyRequest;
}
type TransitImportKeyRequestQuery = {};
type TransitImportKeyRouteParameters = {};
type TransitImportKeyRequestHeaders = {};
interface TransitImportKeyParameterBodies {
  'application/json': TransitImportKeyRequest & {
    [key: string]: any;
  };
}
type TransitImportKeyRequestParameters = TransitImportKeyRequestQuery & TransitImportKeyRouteParameters & TransitImportKeyRequestHeaders & TransitImportKeyRequestBodies['application/json'];
interface TransitImportKeyOperation<STATUS extends keyof TransitImportKeyResponseBodies, CONTENT_TYPE extends keyof TransitImportKeyParameterBodies> extends KeqOperation {
  requestParams: TransitImportKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitImportKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitImportKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitImportKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitImportKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-import-key-version-request.schema.d.ts
interface TransitImportKeyVersionRequest {
  /**
   * The base64-encoded ciphertext of the keys. The AES key should be encrypted using OAEP with the wrapping key and then concatenated with the import key, wrapped by the AES key.
   */
  ciphertext?: string;
  /**
   * The hash function used as a random oracle in the OAEP wrapping of the user-generated, ephemeral AES key. Can be one of "SHA1", "SHA224", "SHA256" (default), "SHA384", or "SHA512"
   */
  hash_function?: string;
  /**
   * The plaintext public key to be imported. If "ciphertext" is set, this field is ignored.
   */
  public_key?: string;
  /**
   * Key version to be updated, if left empty, a new version will be created unless a private key is specified and the 'Latest' key is missing a private key.
   */
  version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-import-key-version.type.d.ts
interface TransitImportKeyVersionResponseBodies {
  200: void;
}
interface TransitImportKeyVersionRequestBodies {
  'application/json': TransitImportKeyVersionRequest;
}
type TransitImportKeyVersionRequestQuery = {};
type TransitImportKeyVersionRouteParameters = {};
type TransitImportKeyVersionRequestHeaders = {};
interface TransitImportKeyVersionParameterBodies {
  'application/json': TransitImportKeyVersionRequest & {
    [key: string]: any;
  };
}
type TransitImportKeyVersionRequestParameters = TransitImportKeyVersionRequestQuery & TransitImportKeyVersionRouteParameters & TransitImportKeyVersionRequestHeaders & TransitImportKeyVersionRequestBodies['application/json'];
interface TransitImportKeyVersionOperation<STATUS extends keyof TransitImportKeyVersionResponseBodies, CONTENT_TYPE extends keyof TransitImportKeyVersionParameterBodies> extends KeqOperation {
  requestParams: TransitImportKeyVersionRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitImportKeyVersionRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitImportKeyVersionRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitImportKeyVersionParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitImportKeyVersionResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-rotate-key.type.d.ts
interface TransitRotateKeyResponseBodies {
  200: void;
}
type TransitRotateKeyRequestQuery = {};
type TransitRotateKeyRouteParameters = {};
type TransitRotateKeyRequestHeaders = {};
type TransitRotateKeyRequestParameters = TransitRotateKeyRequestQuery & TransitRotateKeyRouteParameters & TransitRotateKeyRequestHeaders;
interface TransitRotateKeyOperation<STATUS extends keyof TransitRotateKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitRotateKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitRotateKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitRotateKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitRotateKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/set-chain-request.schema.d.ts
interface SetChainRequest {
  /**
   * PEM encoded certificate chain. It should be composed by one or more concatenated PEM blocks and ordered starting from the end-entity certificate.
   */
  certificate_chain: string;
  /**
   * Version of the key to import the certificate chain against.
   */
  version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/set-chain.type.d.ts
interface SetChainResponseBodies {
  200: void;
}
interface SetChainRequestBodies {
  'application/json': SetChainRequest;
}
type SetChainRequestQuery = {};
type SetChainRouteParameters = {};
type SetChainRequestHeaders = {};
interface SetChainParameterBodies {
  'application/json': SetChainRequest & {
    [key: string]: any;
  };
}
type SetChainRequestParameters = SetChainRequestQuery & SetChainRouteParameters & SetChainRequestHeaders & SetChainRequestBodies['application/json'];
interface SetChainOperation<STATUS extends keyof SetChainResponseBodies, CONTENT_TYPE extends keyof SetChainParameterBodies> extends KeqOperation {
  requestParams: SetChainRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: SetChainRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: SetChainRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: SetChainParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: SetChainResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-soft-delete-key.type.d.ts
interface TransitSoftDeleteKeyResponseBodies {
  204: void;
}
type TransitSoftDeleteKeyRequestQuery = {};
type TransitSoftDeleteKeyRouteParameters = {};
type TransitSoftDeleteKeyRequestHeaders = {};
type TransitSoftDeleteKeyRequestParameters = TransitSoftDeleteKeyRequestQuery & TransitSoftDeleteKeyRouteParameters & TransitSoftDeleteKeyRequestHeaders;
interface TransitSoftDeleteKeyOperation<STATUS extends keyof TransitSoftDeleteKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitSoftDeleteKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitSoftDeleteKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitSoftDeleteKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitSoftDeleteKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-soft-delete-restore-key.type.d.ts
interface TransitSoftDeleteRestoreKeyResponseBodies {
  200: void;
}
type TransitSoftDeleteRestoreKeyRequestQuery = {};
type TransitSoftDeleteRestoreKeyRouteParameters = {};
type TransitSoftDeleteRestoreKeyRequestHeaders = {};
type TransitSoftDeleteRestoreKeyRequestParameters = TransitSoftDeleteRestoreKeyRequestQuery & TransitSoftDeleteRestoreKeyRouteParameters & TransitSoftDeleteRestoreKeyRequestHeaders;
interface TransitSoftDeleteRestoreKeyOperation<STATUS extends keyof TransitSoftDeleteRestoreKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitSoftDeleteRestoreKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitSoftDeleteRestoreKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitSoftDeleteRestoreKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitSoftDeleteRestoreKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-trim-key-request.schema.d.ts
interface TransitTrimKeyRequest {
  /**
   * The minimum available version for the key ring. All versions before this version will be permanently deleted. This value can at most be equal to the lesser of 'min_decryption_version' and 'min_encryption_version'. This is not allowed to be set when either 'min_encryption_version' or 'min_decryption_version' is set to zero.
   */
  min_available_version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-trim-key.type.d.ts
interface TransitTrimKeyResponseBodies {
  200: void;
}
interface TransitTrimKeyRequestBodies {
  'application/json': TransitTrimKeyRequest;
}
type TransitTrimKeyRequestQuery = {};
type TransitTrimKeyRouteParameters = {};
type TransitTrimKeyRequestHeaders = {};
interface TransitTrimKeyParameterBodies {
  'application/json': TransitTrimKeyRequest & {
    [key: string]: any;
  };
}
type TransitTrimKeyRequestParameters = TransitTrimKeyRequestQuery & TransitTrimKeyRouteParameters & TransitTrimKeyRequestHeaders & TransitTrimKeyRequestBodies['application/json'];
interface TransitTrimKeyOperation<STATUS extends keyof TransitTrimKeyResponseBodies, CONTENT_TYPE extends keyof TransitTrimKeyParameterBodies> extends KeqOperation {
  requestParams: TransitTrimKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitTrimKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitTrimKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitTrimKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitTrimKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-random-request.schema.d.ts
interface TransitGenerateRandomRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * Which system to source random data from, ether "platform", "seal", or "all".
   */
  source?: string;
  /**
   * The number of bytes to generate (POST URL parameter)
   */
  urlbytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-random.type.d.ts
interface TransitGenerateRandomResponseBodies {
  200: void;
}
interface TransitGenerateRandomRequestBodies {
  'application/json': TransitGenerateRandomRequest;
}
type TransitGenerateRandomRequestQuery = {};
type TransitGenerateRandomRouteParameters = {};
type TransitGenerateRandomRequestHeaders = {};
interface TransitGenerateRandomParameterBodies {
  'application/json': TransitGenerateRandomRequest & {
    [key: string]: any;
  };
}
type TransitGenerateRandomRequestParameters = TransitGenerateRandomRequestQuery & TransitGenerateRandomRouteParameters & TransitGenerateRandomRequestHeaders & TransitGenerateRandomRequestBodies['application/json'];
interface TransitGenerateRandomOperation<STATUS extends keyof TransitGenerateRandomResponseBodies, CONTENT_TYPE extends keyof TransitGenerateRandomParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateRandomRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateRandomRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateRandomRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateRandomParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateRandomResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-random-with-source-request.schema.d.ts
interface TransitGenerateRandomWithSourceRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * The number of bytes to generate (POST URL parameter)
   */
  urlbytes?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-random-with-source.type.d.ts
interface TransitGenerateRandomWithSourceResponseBodies {
  200: void;
}
interface TransitGenerateRandomWithSourceRequestBodies {
  'application/json': TransitGenerateRandomWithSourceRequest;
}
type TransitGenerateRandomWithSourceRequestQuery = {};
type TransitGenerateRandomWithSourceRouteParameters = {};
type TransitGenerateRandomWithSourceRequestHeaders = {};
interface TransitGenerateRandomWithSourceParameterBodies {
  'application/json': TransitGenerateRandomWithSourceRequest & {
    [key: string]: any;
  };
}
type TransitGenerateRandomWithSourceRequestParameters = TransitGenerateRandomWithSourceRequestQuery & TransitGenerateRandomWithSourceRouteParameters & TransitGenerateRandomWithSourceRequestHeaders & TransitGenerateRandomWithSourceRequestBodies['application/json'];
interface TransitGenerateRandomWithSourceOperation<STATUS extends keyof TransitGenerateRandomWithSourceResponseBodies, CONTENT_TYPE extends keyof TransitGenerateRandomWithSourceParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateRandomWithSourceRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateRandomWithSourceRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateRandomWithSourceRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateRandomWithSourceParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateRandomWithSourceResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-random-with-source-and-bytes-request.schema.d.ts
interface TransitGenerateRandomWithSourceAndBytesRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-random-with-source-and-bytes.type.d.ts
interface TransitGenerateRandomWithSourceAndBytesResponseBodies {
  200: void;
}
interface TransitGenerateRandomWithSourceAndBytesRequestBodies {
  'application/json': TransitGenerateRandomWithSourceAndBytesRequest;
}
type TransitGenerateRandomWithSourceAndBytesRequestQuery = {};
type TransitGenerateRandomWithSourceAndBytesRouteParameters = {};
type TransitGenerateRandomWithSourceAndBytesRequestHeaders = {};
interface TransitGenerateRandomWithSourceAndBytesParameterBodies {
  'application/json': TransitGenerateRandomWithSourceAndBytesRequest & {
    [key: string]: any;
  };
}
type TransitGenerateRandomWithSourceAndBytesRequestParameters = TransitGenerateRandomWithSourceAndBytesRequestQuery & TransitGenerateRandomWithSourceAndBytesRouteParameters & TransitGenerateRandomWithSourceAndBytesRequestHeaders & TransitGenerateRandomWithSourceAndBytesRequestBodies['application/json'];
interface TransitGenerateRandomWithSourceAndBytesOperation<STATUS extends keyof TransitGenerateRandomWithSourceAndBytesResponseBodies, CONTENT_TYPE extends keyof TransitGenerateRandomWithSourceAndBytesParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateRandomWithSourceAndBytesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateRandomWithSourceAndBytesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateRandomWithSourceAndBytesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateRandomWithSourceAndBytesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateRandomWithSourceAndBytesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-generate-random-with-bytes-request.schema.d.ts
interface TransitGenerateRandomWithBytesRequest {
  /**
   * The number of bytes to generate (POST body parameter). Defaults to 32 (256 bits).
   */
  bytes?: number;
  /**
   * Encoding format to use. Can be "hex" or "base64". Defaults to "base64".
   */
  format?: string;
  /**
   * Which system to source random data from, ether "platform", "seal", or "all".
   */
  source?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-generate-random-with-bytes.type.d.ts
interface TransitGenerateRandomWithBytesResponseBodies {
  200: void;
}
interface TransitGenerateRandomWithBytesRequestBodies {
  'application/json': TransitGenerateRandomWithBytesRequest;
}
type TransitGenerateRandomWithBytesRequestQuery = {};
type TransitGenerateRandomWithBytesRouteParameters = {};
type TransitGenerateRandomWithBytesRequestHeaders = {};
interface TransitGenerateRandomWithBytesParameterBodies {
  'application/json': TransitGenerateRandomWithBytesRequest & {
    [key: string]: any;
  };
}
type TransitGenerateRandomWithBytesRequestParameters = TransitGenerateRandomWithBytesRequestQuery & TransitGenerateRandomWithBytesRouteParameters & TransitGenerateRandomWithBytesRequestHeaders & TransitGenerateRandomWithBytesRequestBodies['application/json'];
interface TransitGenerateRandomWithBytesOperation<STATUS extends keyof TransitGenerateRandomWithBytesResponseBodies, CONTENT_TYPE extends keyof TransitGenerateRandomWithBytesParameterBodies> extends KeqOperation {
  requestParams: TransitGenerateRandomWithBytesRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitGenerateRandomWithBytesRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitGenerateRandomWithBytesRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitGenerateRandomWithBytesParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitGenerateRandomWithBytesResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-restore-key-request.schema.d.ts
interface TransitRestoreKeyRequest {
  /**
   * Backed up key data to be restored. This should be the output from the 'backup/' endpoint.
   */
  backup?: string;
  /**
   * If set and a key by the given name exists, force the restore operation and override the key.
   */
  force?: boolean;
  /**
   * If set, this will be the name of the restored key.
   */
  name?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-restore-key.type.d.ts
interface TransitRestoreKeyResponseBodies {
  200: void;
}
interface TransitRestoreKeyRequestBodies {
  'application/json': TransitRestoreKeyRequest;
}
type TransitRestoreKeyRequestQuery = {};
type TransitRestoreKeyRouteParameters = {};
type TransitRestoreKeyRequestHeaders = {};
interface TransitRestoreKeyParameterBodies {
  'application/json': TransitRestoreKeyRequest & {
    [key: string]: any;
  };
}
type TransitRestoreKeyRequestParameters = TransitRestoreKeyRequestQuery & TransitRestoreKeyRouteParameters & TransitRestoreKeyRequestHeaders & TransitRestoreKeyRequestBodies['application/json'];
interface TransitRestoreKeyOperation<STATUS extends keyof TransitRestoreKeyResponseBodies, CONTENT_TYPE extends keyof TransitRestoreKeyParameterBodies> extends KeqOperation {
  requestParams: TransitRestoreKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitRestoreKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitRestoreKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitRestoreKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitRestoreKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-restore-and-rename-key-request.schema.d.ts
interface TransitRestoreAndRenameKeyRequest {
  /**
   * Backed up key data to be restored. This should be the output from the 'backup/' endpoint.
   */
  backup?: string;
  /**
   * If set and a key by the given name exists, force the restore operation and override the key.
   */
  force?: boolean;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-restore-and-rename-key.type.d.ts
interface TransitRestoreAndRenameKeyResponseBodies {
  200: void;
}
interface TransitRestoreAndRenameKeyRequestBodies {
  'application/json': TransitRestoreAndRenameKeyRequest;
}
type TransitRestoreAndRenameKeyRequestQuery = {};
type TransitRestoreAndRenameKeyRouteParameters = {};
type TransitRestoreAndRenameKeyRequestHeaders = {};
interface TransitRestoreAndRenameKeyParameterBodies {
  'application/json': TransitRestoreAndRenameKeyRequest & {
    [key: string]: any;
  };
}
type TransitRestoreAndRenameKeyRequestParameters = TransitRestoreAndRenameKeyRequestQuery & TransitRestoreAndRenameKeyRouteParameters & TransitRestoreAndRenameKeyRequestHeaders & TransitRestoreAndRenameKeyRequestBodies['application/json'];
interface TransitRestoreAndRenameKeyOperation<STATUS extends keyof TransitRestoreAndRenameKeyResponseBodies, CONTENT_TYPE extends keyof TransitRestoreAndRenameKeyParameterBodies> extends KeqOperation {
  requestParams: TransitRestoreAndRenameKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitRestoreAndRenameKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitRestoreAndRenameKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitRestoreAndRenameKeyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitRestoreAndRenameKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-rewrap-request.schema.d.ts
interface TransitRewrapRequest {
  /**
   * Specifies a list of items to be re-encrypted in a single batch. When this parameter is set, if the parameters 'ciphertext' and 'context' are also set, they will be ignored. Any batch output will preserve the order of the batch input.
   */
  batch_input?: Record<string, never>[];
  /**
   * Ciphertext value to rewrap
   */
  ciphertext?: string;
  /**
   * Base64 encoded context for key derivation. Required for derived keys.
   */
  context?: string;
  /**
   * The version of the key to use for encryption. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-rewrap.type.d.ts
interface TransitRewrapResponseBodies {
  200: void;
}
interface TransitRewrapRequestBodies {
  'application/json': TransitRewrapRequest;
}
type TransitRewrapRequestQuery = {};
type TransitRewrapRouteParameters = {};
type TransitRewrapRequestHeaders = {};
interface TransitRewrapParameterBodies {
  'application/json': TransitRewrapRequest & {
    [key: string]: any;
  };
}
type TransitRewrapRequestParameters = TransitRewrapRequestQuery & TransitRewrapRouteParameters & TransitRewrapRequestHeaders & TransitRewrapRequestBodies['application/json'];
interface TransitRewrapOperation<STATUS extends keyof TransitRewrapResponseBodies, CONTENT_TYPE extends keyof TransitRewrapParameterBodies> extends KeqOperation {
  requestParams: TransitRewrapRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitRewrapRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitRewrapRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitRewrapParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitRewrapResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-sign-request.schema.d.ts
interface TransitSignRequest {
  /**
   * Deprecated: use "hash_algorithm" instead.
   */
  algorithm?: string;
  /**
   * Specifies a list of items for processing. When this parameter is set, any supplied 'input' or 'context' parameters will be ignored. Responses are returned in the 'batch_results' array component of the 'data' element of the response. Any batch output will preserve the order of the batch input
   */
  batch_input?: Record<string, never>[];
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled; currently only available with ed25519 keys.
   */
  context?: string;
  /**
   * Hash algorithm to use (POST body parameter). Valid values are: * sha1 * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 * none Defaults to "sha2-256". Not valid for all key types, including ed25519. Using none requires setting prehashed=true and signature_algorithm=pkcs1v15, yielding a PKCSv1_5_NoOID instead of the usual PKCSv1_5_DERnull signature.
   */
  hash_algorithm?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * The version of the key to use for signing. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
  /**
   * The method by which to marshal the signature. The default is 'asn1' which is used by openssl and X.509. It can also be set to 'jws' which is used for JWT signatures; setting it to this will also cause the encoding of the signature to be url-safe base64 instead of using standard base64 encoding. Currently only valid for ECDSA P-256 key types".
   */
  marshaling_algorithm?: string;
  /**
   * Set to 'true' when the input is already hashed. If the key type is 'rsa-2048', 'rsa-3072' or 'rsa-4096', then the algorithm used to hash the input should be indicated by the 'algorithm' parameter.
   */
  prehashed?: boolean;
  /**
   * The salt length used to sign. Currently only applies to the RSA PSS signature scheme. Options are 'auto' (the default used by Golang, causing the salt to be as large as possible when signing), 'hash' (causes the salt length to equal the length of the hash used in the signature), or an integer between the minimum and the maximum permissible salt lengths for the given RSA key size. Defaults to 'auto'.
   */
  salt_length?: string;
  /**
   * The signature algorithm to use for signing. Currently only applies to RSA key types. Options are 'pss' or 'pkcs1v15'. Defaults to 'pss'
   */
  signature_algorithm?: string;
  /**
   * Hash algorithm to use (POST URL parameter)
   */
  urlalgorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-sign.type.d.ts
interface TransitSignResponseBodies {
  200: void;
}
interface TransitSignRequestBodies {
  'application/json': TransitSignRequest;
}
type TransitSignRequestQuery = {};
type TransitSignRouteParameters = {};
type TransitSignRequestHeaders = {};
interface TransitSignParameterBodies {
  'application/json': TransitSignRequest & {
    [key: string]: any;
  };
}
type TransitSignRequestParameters = TransitSignRequestQuery & TransitSignRouteParameters & TransitSignRequestHeaders & TransitSignRequestBodies['application/json'];
interface TransitSignOperation<STATUS extends keyof TransitSignResponseBodies, CONTENT_TYPE extends keyof TransitSignParameterBodies> extends KeqOperation {
  requestParams: TransitSignRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitSignRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitSignRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitSignParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitSignResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-sign-with-algorithm-request.schema.d.ts
interface TransitSignWithAlgorithmRequest {
  /**
   * Deprecated: use "hash_algorithm" instead.
   */
  algorithm?: string;
  /**
   * Specifies a list of items for processing. When this parameter is set, any supplied 'input' or 'context' parameters will be ignored. Responses are returned in the 'batch_results' array component of the 'data' element of the response. Any batch output will preserve the order of the batch input
   */
  batch_input?: Record<string, never>[];
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled; currently only available with ed25519 keys.
   */
  context?: string;
  /**
   * Hash algorithm to use (POST body parameter). Valid values are: * sha1 * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 * none Defaults to "sha2-256". Not valid for all key types, including ed25519. Using none requires setting prehashed=true and signature_algorithm=pkcs1v15, yielding a PKCSv1_5_NoOID instead of the usual PKCSv1_5_DERnull signature.
   */
  hash_algorithm?: string;
  /**
   * The base64-encoded input data
   */
  input?: string;
  /**
   * The version of the key to use for signing. Must be 0 (for latest) or a value greater than or equal to the min_encryption_version configured on the key.
   */
  key_version?: number;
  /**
   * The method by which to marshal the signature. The default is 'asn1' which is used by openssl and X.509. It can also be set to 'jws' which is used for JWT signatures; setting it to this will also cause the encoding of the signature to be url-safe base64 instead of using standard base64 encoding. Currently only valid for ECDSA P-256 key types".
   */
  marshaling_algorithm?: string;
  /**
   * Set to 'true' when the input is already hashed. If the key type is 'rsa-2048', 'rsa-3072' or 'rsa-4096', then the algorithm used to hash the input should be indicated by the 'algorithm' parameter.
   */
  prehashed?: boolean;
  /**
   * The salt length used to sign. Currently only applies to the RSA PSS signature scheme. Options are 'auto' (the default used by Golang, causing the salt to be as large as possible when signing), 'hash' (causes the salt length to equal the length of the hash used in the signature), or an integer between the minimum and the maximum permissible salt lengths for the given RSA key size. Defaults to 'auto'.
   */
  salt_length?: string;
  /**
   * The signature algorithm to use for signing. Currently only applies to RSA key types. Options are 'pss' or 'pkcs1v15'. Defaults to 'pss'
   */
  signature_algorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-sign-with-algorithm.type.d.ts
interface TransitSignWithAlgorithmResponseBodies {
  200: void;
}
interface TransitSignWithAlgorithmRequestBodies {
  'application/json': TransitSignWithAlgorithmRequest;
}
type TransitSignWithAlgorithmRequestQuery = {};
type TransitSignWithAlgorithmRouteParameters = {};
type TransitSignWithAlgorithmRequestHeaders = {};
interface TransitSignWithAlgorithmParameterBodies {
  'application/json': TransitSignWithAlgorithmRequest & {
    [key: string]: any;
  };
}
type TransitSignWithAlgorithmRequestParameters = TransitSignWithAlgorithmRequestQuery & TransitSignWithAlgorithmRouteParameters & TransitSignWithAlgorithmRequestHeaders & TransitSignWithAlgorithmRequestBodies['application/json'];
interface TransitSignWithAlgorithmOperation<STATUS extends keyof TransitSignWithAlgorithmResponseBodies, CONTENT_TYPE extends keyof TransitSignWithAlgorithmParameterBodies> extends KeqOperation {
  requestParams: TransitSignWithAlgorithmRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitSignWithAlgorithmRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitSignWithAlgorithmRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitSignWithAlgorithmParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitSignWithAlgorithmResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-verify-request.schema.d.ts
interface TransitVerifyRequest {
  /**
   * Deprecated: use "hash_algorithm" instead.
   */
  algorithm?: string;
  /**
   * Specifies a list of items for processing. When this parameter is set, any supplied 'input', 'hmac' or 'signature' parameters will be ignored. Responses are returned in the 'batch_results' array component of the 'data' element of the response. Any batch output will preserve the order of the batch input
   */
  batch_input?: Record<string, never>[];
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled; currently only available with ed25519 keys.
   */
  context?: string;
  /**
   * Hash algorithm to use (POST body parameter). Valid values are: * sha1 * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 * none Defaults to "sha2-256". Not valid for all key types. See note about none on signing path.
   */
  hash_algorithm?: string;
  /**
   * The HMAC, including OpenBao header/key version
   */
  hmac?: string;
  /**
   * The base64-encoded input data to verify
   */
  input?: string;
  /**
   * The method by which to unmarshal the signature when verifying. The default is 'asn1' which is used by openssl and X.509; can also be set to 'jws' which is used for JWT signatures in which case the signature is also expected to be url-safe base64 encoding instead of standard base64 encoding. Currently only valid for ECDSA P-256 key types".
   */
  marshaling_algorithm?: string;
  /**
   * Set to 'true' when the input is already hashed. If the key type is 'rsa-2048', 'rsa-3072' or 'rsa-4096', then the algorithm used to hash the input should be indicated by the 'algorithm' parameter.
   */
  prehashed?: boolean;
  /**
   * The salt length used to sign. Currently only applies to the RSA PSS signature scheme. Options are 'auto' (the default used by Golang, causing the salt to be as large as possible when signing), 'hash' (causes the salt length to equal the length of the hash used in the signature), or an integer between the minimum and the maximum permissible salt lengths for the given RSA key size. Defaults to 'auto'.
   */
  salt_length?: string;
  /**
   * The signature, including OpenBao header/key version
   */
  signature?: string;
  /**
   * The signature algorithm to use for signature verification. Currently only applies to RSA key types. Options are 'pss' or 'pkcs1v15'. Defaults to 'pss'
   */
  signature_algorithm?: string;
  /**
   * Hash algorithm to use (POST URL parameter)
   */
  urlalgorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-verify.type.d.ts
interface TransitVerifyResponseBodies {
  200: void;
}
interface TransitVerifyRequestBodies {
  'application/json': TransitVerifyRequest;
}
type TransitVerifyRequestQuery = {};
type TransitVerifyRouteParameters = {};
type TransitVerifyRequestHeaders = {};
interface TransitVerifyParameterBodies {
  'application/json': TransitVerifyRequest & {
    [key: string]: any;
  };
}
type TransitVerifyRequestParameters = TransitVerifyRequestQuery & TransitVerifyRouteParameters & TransitVerifyRequestHeaders & TransitVerifyRequestBodies['application/json'];
interface TransitVerifyOperation<STATUS extends keyof TransitVerifyResponseBodies, CONTENT_TYPE extends keyof TransitVerifyParameterBodies> extends KeqOperation {
  requestParams: TransitVerifyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitVerifyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitVerifyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitVerifyParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitVerifyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/components/schemas/transit-verify-with-algorithm-request.schema.d.ts
interface TransitVerifyWithAlgorithmRequest {
  /**
   * Deprecated: use "hash_algorithm" instead.
   */
  algorithm?: string;
  /**
   * Specifies a list of items for processing. When this parameter is set, any supplied 'input', 'hmac' or 'signature' parameters will be ignored. Responses are returned in the 'batch_results' array component of the 'data' element of the response. Any batch output will preserve the order of the batch input
   */
  batch_input?: Record<string, never>[];
  /**
   * Base64 encoded context for key derivation. Required if key derivation is enabled; currently only available with ed25519 keys.
   */
  context?: string;
  /**
   * Hash algorithm to use (POST body parameter). Valid values are: * sha1 * sha2-224 * sha2-256 * sha2-384 * sha2-512 * sha3-224 * sha3-256 * sha3-384 * sha3-512 * none Defaults to "sha2-256". Not valid for all key types. See note about none on signing path.
   */
  hash_algorithm?: string;
  /**
   * The HMAC, including OpenBao header/key version
   */
  hmac?: string;
  /**
   * The base64-encoded input data to verify
   */
  input?: string;
  /**
   * The method by which to unmarshal the signature when verifying. The default is 'asn1' which is used by openssl and X.509; can also be set to 'jws' which is used for JWT signatures in which case the signature is also expected to be url-safe base64 encoding instead of standard base64 encoding. Currently only valid for ECDSA P-256 key types".
   */
  marshaling_algorithm?: string;
  /**
   * Set to 'true' when the input is already hashed. If the key type is 'rsa-2048', 'rsa-3072' or 'rsa-4096', then the algorithm used to hash the input should be indicated by the 'algorithm' parameter.
   */
  prehashed?: boolean;
  /**
   * The salt length used to sign. Currently only applies to the RSA PSS signature scheme. Options are 'auto' (the default used by Golang, causing the salt to be as large as possible when signing), 'hash' (causes the salt length to equal the length of the hash used in the signature), or an integer between the minimum and the maximum permissible salt lengths for the given RSA key size. Defaults to 'auto'.
   */
  salt_length?: string;
  /**
   * The signature, including OpenBao header/key version
   */
  signature?: string;
  /**
   * The signature algorithm to use for signature verification. Currently only applies to RSA key types. Options are 'pss' or 'pkcs1v15'. Defaults to 'pss'
   */
  signature_algorithm?: string;
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-verify-with-algorithm.type.d.ts
interface TransitVerifyWithAlgorithmResponseBodies {
  200: void;
}
interface TransitVerifyWithAlgorithmRequestBodies {
  'application/json': TransitVerifyWithAlgorithmRequest;
}
type TransitVerifyWithAlgorithmRequestQuery = {};
type TransitVerifyWithAlgorithmRouteParameters = {};
type TransitVerifyWithAlgorithmRequestHeaders = {};
interface TransitVerifyWithAlgorithmParameterBodies {
  'application/json': TransitVerifyWithAlgorithmRequest & {
    [key: string]: any;
  };
}
type TransitVerifyWithAlgorithmRequestParameters = TransitVerifyWithAlgorithmRequestQuery & TransitVerifyWithAlgorithmRouteParameters & TransitVerifyWithAlgorithmRequestHeaders & TransitVerifyWithAlgorithmRequestBodies['application/json'];
interface TransitVerifyWithAlgorithmOperation<STATUS extends keyof TransitVerifyWithAlgorithmResponseBodies, CONTENT_TYPE extends keyof TransitVerifyWithAlgorithmParameterBodies> extends KeqOperation {
  requestParams: TransitVerifyWithAlgorithmRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitVerifyWithAlgorithmRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitVerifyWithAlgorithmRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: TransitVerifyWithAlgorithmParameterBodies[CONTENT_TYPE] | BodyInit;
  responseBody: TransitVerifyWithAlgorithmResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/types/operations/transit-read-wrapping-key.type.d.ts
interface TransitReadWrappingKeyResponseBodies {
  200: void;
}
type TransitReadWrappingKeyRequestQuery = {};
type TransitReadWrappingKeyRouteParameters = {};
type TransitReadWrappingKeyRequestHeaders = {};
type TransitReadWrappingKeyRequestParameters = TransitReadWrappingKeyRequestQuery & TransitReadWrappingKeyRouteParameters & TransitReadWrappingKeyRequestHeaders;
interface TransitReadWrappingKeyOperation<STATUS extends keyof TransitReadWrappingKeyResponseBodies, CONTENT_TYPE extends string> extends KeqOperation {
  requestParams: TransitReadWrappingKeyRouteParameters & {
    [key: string]: KeqPathParameterInit;
  };
  requestQuery: TransitReadWrappingKeyRequestQuery & {
    [key: string]: KeqQueryInit;
  };
  requestHeaders: TransitReadWrappingKeyRequestHeaders & {
    [key: string]: string | number;
  };
  requestBody: object | BodyInit;
  responseBody: TransitReadWrappingKeyResponseBodies[STATUS];
}
//#endregion
//#region src/apis/open-bao-http/open-bao-http.client.d.ts
declare class OpenBaoHttpClient {
  private readonly request;
  private readonly logger;
  constructor(request: KeqRequest);
  kubernetesReadAuthConfiguration<STATUS extends keyof KubernetesReadAuthConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: KubernetesReadAuthConfigurationRequestParameters): Keq<KubernetesReadAuthConfigurationOperation<STATUS, CONTENT_TYPE>>;
  kubernetesConfigureAuth<STATUS extends keyof KubernetesConfigureAuthResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KubernetesConfigureAuthRequestParameters): Keq<KubernetesConfigureAuthOperation<STATUS, CONTENT_TYPE>>;
  kubernetesLogin<STATUS extends keyof KubernetesLoginResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KubernetesLoginRequestParameters): Keq<KubernetesLoginOperation<STATUS, CONTENT_TYPE>>;
  kubernetesListAuthRoles<STATUS extends keyof KubernetesListAuthRolesResponseBodies, CONTENT_TYPE extends never = never>(args?: KubernetesListAuthRolesRequestParameters): Keq<KubernetesListAuthRolesOperation<STATUS, CONTENT_TYPE>>;
  kubernetesReadAuthRole<STATUS extends keyof KubernetesReadAuthRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: KubernetesReadAuthRoleRequestParameters): Keq<KubernetesReadAuthRoleOperation<STATUS, CONTENT_TYPE>>;
  kubernetesWriteAuthRole<STATUS extends keyof KubernetesWriteAuthRoleResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KubernetesWriteAuthRoleRequestParameters): Keq<KubernetesWriteAuthRoleOperation<STATUS, CONTENT_TYPE>>;
  kubernetesDeleteAuthRole<STATUS extends keyof KubernetesDeleteAuthRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: KubernetesDeleteAuthRoleRequestParameters): Keq<KubernetesDeleteAuthRoleOperation<STATUS, CONTENT_TYPE>>;
  tokenListAccessors<STATUS extends keyof TokenListAccessorsResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenListAccessorsRequestParameters): Keq<TokenListAccessorsOperation<STATUS, CONTENT_TYPE>>;
  tokenCreate<STATUS extends keyof TokenCreateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenCreateRequestParameters): Keq<TokenCreateOperation<STATUS, CONTENT_TYPE>>;
  tokenCreateOrphan<STATUS extends keyof TokenCreateOrphanResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenCreateOrphanRequestParameters): Keq<TokenCreateOrphanOperation<STATUS, CONTENT_TYPE>>;
  tokenCreateAgainstRole<STATUS extends keyof TokenCreateAgainstRoleResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenCreateAgainstRoleRequestParameters): Keq<TokenCreateAgainstRoleOperation<STATUS, CONTENT_TYPE>>;
  tokenLookUpGet<STATUS extends keyof TokenLookUpGetResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenLookUpGetRequestParameters): Keq<TokenLookUpGetOperation<STATUS, CONTENT_TYPE>>;
  tokenLookUpUpdate<STATUS extends keyof TokenLookUpUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenLookUpUpdateRequestParameters): Keq<TokenLookUpUpdateOperation<STATUS, CONTENT_TYPE>>;
  tokenLookUpByAccessor<STATUS extends keyof TokenLookUpByAccessorResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenLookUpByAccessorRequestParameters): Keq<TokenLookUpByAccessorOperation<STATUS, CONTENT_TYPE>>;
  tokenLookUpSelfGet<STATUS extends keyof TokenLookUpSelfGetResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenLookUpSelfGetRequestParameters): Keq<TokenLookUpSelfGetOperation<STATUS, CONTENT_TYPE>>;
  tokenLookUpSelfUpdate<STATUS extends keyof TokenLookUpSelfUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenLookUpSelfUpdateRequestParameters): Keq<TokenLookUpSelfUpdateOperation<STATUS, CONTENT_TYPE>>;
  tokenRenew<STATUS extends keyof TokenRenewResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRenewRequestParameters): Keq<TokenRenewOperation<STATUS, CONTENT_TYPE>>;
  tokenRenewAccessor<STATUS extends keyof TokenRenewAccessorResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRenewAccessorRequestParameters): Keq<TokenRenewAccessorOperation<STATUS, CONTENT_TYPE>>;
  tokenRenewSelf<STATUS extends keyof TokenRenewSelfResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRenewSelfRequestParameters): Keq<TokenRenewSelfOperation<STATUS, CONTENT_TYPE>>;
  tokenRevoke<STATUS extends keyof TokenRevokeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRevokeRequestParameters): Keq<TokenRevokeOperation<STATUS, CONTENT_TYPE>>;
  tokenRevokeAccessor<STATUS extends keyof TokenRevokeAccessorResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRevokeAccessorRequestParameters): Keq<TokenRevokeAccessorOperation<STATUS, CONTENT_TYPE>>;
  tokenRevokeOrphan<STATUS extends keyof TokenRevokeOrphanResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenRevokeOrphanRequestParameters): Keq<TokenRevokeOrphanOperation<STATUS, CONTENT_TYPE>>;
  tokenRevokeSelf<STATUS extends keyof TokenRevokeSelfResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenRevokeSelfRequestParameters): Keq<TokenRevokeSelfOperation<STATUS, CONTENT_TYPE>>;
  tokenListRoles<STATUS extends keyof TokenListRolesResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenListRolesRequestParameters): Keq<TokenListRolesOperation<STATUS, CONTENT_TYPE>>;
  tokenReadRole<STATUS extends keyof TokenReadRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenReadRoleRequestParameters): Keq<TokenReadRoleOperation<STATUS, CONTENT_TYPE>>;
  tokenWriteRole<STATUS extends keyof TokenWriteRoleResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TokenWriteRoleRequestParameters): Keq<TokenWriteRoleOperation<STATUS, CONTENT_TYPE>>;
  tokenDeleteRole<STATUS extends keyof TokenDeleteRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenDeleteRoleRequestParameters): Keq<TokenDeleteRoleOperation<STATUS, CONTENT_TYPE>>;
  tokenTidy<STATUS extends keyof TokenTidyResponseBodies, CONTENT_TYPE extends never = never>(args?: TokenTidyRequestParameters): Keq<TokenTidyOperation<STATUS, CONTENT_TYPE>>;
  userpassLogin<STATUS extends keyof UserpassLoginResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UserpassLoginRequestParameters): Keq<UserpassLoginOperation<STATUS, CONTENT_TYPE>>;
  userpassListUsers<STATUS extends keyof UserpassListUsersResponseBodies, CONTENT_TYPE extends never = never>(args?: UserpassListUsersRequestParameters): Keq<UserpassListUsersOperation<STATUS, CONTENT_TYPE>>;
  userpassReadUser<STATUS extends keyof UserpassReadUserResponseBodies, CONTENT_TYPE extends never = never>(args?: UserpassReadUserRequestParameters): Keq<UserpassReadUserOperation<STATUS, CONTENT_TYPE>>;
  userpassWriteUser<STATUS extends keyof UserpassWriteUserResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UserpassWriteUserRequestParameters): Keq<UserpassWriteUserOperation<STATUS, CONTENT_TYPE>>;
  userpassDeleteUser<STATUS extends keyof UserpassDeleteUserResponseBodies, CONTENT_TYPE extends never = never>(args?: UserpassDeleteUserRequestParameters): Keq<UserpassDeleteUserOperation<STATUS, CONTENT_TYPE>>;
  userpassResetPassword<STATUS extends keyof UserpassResetPasswordResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UserpassResetPasswordRequestParameters): Keq<UserpassResetPasswordOperation<STATUS, CONTENT_TYPE>>;
  userpassUpdatePolicies<STATUS extends keyof UserpassUpdatePoliciesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UserpassUpdatePoliciesRequestParameters): Keq<UserpassUpdatePoliciesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Retrieve the secret at the specified location.
   *
   */
  cubbyholeRead<STATUS extends keyof CubbyholeReadResponseBodies, CONTENT_TYPE extends never = never>(args?: CubbyholeReadRequestParameters): Keq<CubbyholeReadOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Store a secret at the specified location.
   *
   */
  cubbyholeWrite<STATUS extends keyof CubbyholeWriteResponseBodies, CONTENT_TYPE extends never = never>(args?: CubbyholeWriteRequestParameters): Keq<CubbyholeWriteOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Deletes the secret at the specified location.
   *
   */
  cubbyholeDelete<STATUS extends keyof CubbyholeDeleteResponseBodies, CONTENT_TYPE extends never = never>(args?: CubbyholeDeleteRequestParameters): Keq<CubbyholeDeleteOperation<STATUS, CONTENT_TYPE>>;
  aliasCreate<STATUS extends keyof AliasCreateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AliasCreateRequestParameters): Keq<AliasCreateOperation<STATUS, CONTENT_TYPE>>;
  aliasListById<STATUS extends keyof AliasListByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: AliasListByIdRequestParameters): Keq<AliasListByIdOperation<STATUS, CONTENT_TYPE>>;
  aliasReadById<STATUS extends keyof AliasReadByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: AliasReadByIdRequestParameters): Keq<AliasReadByIdOperation<STATUS, CONTENT_TYPE>>;
  aliasUpdateById<STATUS extends keyof AliasUpdateByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AliasUpdateByIdRequestParameters): Keq<AliasUpdateByIdOperation<STATUS, CONTENT_TYPE>>;
  aliasDeleteById<STATUS extends keyof AliasDeleteByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: AliasDeleteByIdRequestParameters): Keq<AliasDeleteByIdOperation<STATUS, CONTENT_TYPE>>;
  entityCreate<STATUS extends keyof EntityCreateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityCreateRequestParameters): Keq<EntityCreateOperation<STATUS, CONTENT_TYPE>>;
  entityCreateAlias<STATUS extends keyof EntityCreateAliasResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityCreateAliasRequestParameters): Keq<EntityCreateAliasOperation<STATUS, CONTENT_TYPE>>;
  entityListAliasesById<STATUS extends keyof EntityListAliasesByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityListAliasesByIdRequestParameters): Keq<EntityListAliasesByIdOperation<STATUS, CONTENT_TYPE>>;
  entityReadAliasById<STATUS extends keyof EntityReadAliasByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityReadAliasByIdRequestParameters): Keq<EntityReadAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  entityUpdateAliasById<STATUS extends keyof EntityUpdateAliasByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityUpdateAliasByIdRequestParameters): Keq<EntityUpdateAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  entityDeleteAliasById<STATUS extends keyof EntityDeleteAliasByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityDeleteAliasByIdRequestParameters): Keq<EntityDeleteAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  entityBatchDelete<STATUS extends keyof EntityBatchDeleteResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityBatchDeleteRequestParameters): Keq<EntityBatchDeleteOperation<STATUS, CONTENT_TYPE>>;
  entityListById<STATUS extends keyof EntityListByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityListByIdRequestParameters): Keq<EntityListByIdOperation<STATUS, CONTENT_TYPE>>;
  entityReadById<STATUS extends keyof EntityReadByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityReadByIdRequestParameters): Keq<EntityReadByIdOperation<STATUS, CONTENT_TYPE>>;
  entityUpdateById<STATUS extends keyof EntityUpdateByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityUpdateByIdRequestParameters): Keq<EntityUpdateByIdOperation<STATUS, CONTENT_TYPE>>;
  entityDeleteById<STATUS extends keyof EntityDeleteByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityDeleteByIdRequestParameters): Keq<EntityDeleteByIdOperation<STATUS, CONTENT_TYPE>>;
  entityMerge<STATUS extends keyof EntityMergeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityMergeRequestParameters): Keq<EntityMergeOperation<STATUS, CONTENT_TYPE>>;
  entityListByName<STATUS extends keyof EntityListByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityListByNameRequestParameters): Keq<EntityListByNameOperation<STATUS, CONTENT_TYPE>>;
  entityReadByName<STATUS extends keyof EntityReadByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityReadByNameRequestParameters): Keq<EntityReadByNameOperation<STATUS, CONTENT_TYPE>>;
  entityUpdateByName<STATUS extends keyof EntityUpdateByNameResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityUpdateByNameRequestParameters): Keq<EntityUpdateByNameOperation<STATUS, CONTENT_TYPE>>;
  entityDeleteByName<STATUS extends keyof EntityDeleteByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: EntityDeleteByNameRequestParameters): Keq<EntityDeleteByNameOperation<STATUS, CONTENT_TYPE>>;
  groupCreate<STATUS extends keyof GroupCreateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupCreateRequestParameters): Keq<GroupCreateOperation<STATUS, CONTENT_TYPE>>;
  groupCreateAlias<STATUS extends keyof GroupCreateAliasResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupCreateAliasRequestParameters): Keq<GroupCreateAliasOperation<STATUS, CONTENT_TYPE>>;
  groupListAliasesById<STATUS extends keyof GroupListAliasesByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupListAliasesByIdRequestParameters): Keq<GroupListAliasesByIdOperation<STATUS, CONTENT_TYPE>>;
  groupReadAliasById<STATUS extends keyof GroupReadAliasByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupReadAliasByIdRequestParameters): Keq<GroupReadAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  groupUpdateAliasById<STATUS extends keyof GroupUpdateAliasByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupUpdateAliasByIdRequestParameters): Keq<GroupUpdateAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  groupDeleteAliasById<STATUS extends keyof GroupDeleteAliasByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupDeleteAliasByIdRequestParameters): Keq<GroupDeleteAliasByIdOperation<STATUS, CONTENT_TYPE>>;
  groupListById<STATUS extends keyof GroupListByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupListByIdRequestParameters): Keq<GroupListByIdOperation<STATUS, CONTENT_TYPE>>;
  groupReadById<STATUS extends keyof GroupReadByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupReadByIdRequestParameters): Keq<GroupReadByIdOperation<STATUS, CONTENT_TYPE>>;
  groupUpdateById<STATUS extends keyof GroupUpdateByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupUpdateByIdRequestParameters): Keq<GroupUpdateByIdOperation<STATUS, CONTENT_TYPE>>;
  groupDeleteById<STATUS extends keyof GroupDeleteByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupDeleteByIdRequestParameters): Keq<GroupDeleteByIdOperation<STATUS, CONTENT_TYPE>>;
  groupListByName<STATUS extends keyof GroupListByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupListByNameRequestParameters): Keq<GroupListByNameOperation<STATUS, CONTENT_TYPE>>;
  groupReadByName<STATUS extends keyof GroupReadByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupReadByNameRequestParameters): Keq<GroupReadByNameOperation<STATUS, CONTENT_TYPE>>;
  groupUpdateByName<STATUS extends keyof GroupUpdateByNameResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupUpdateByNameRequestParameters): Keq<GroupUpdateByNameOperation<STATUS, CONTENT_TYPE>>;
  groupDeleteByName<STATUS extends keyof GroupDeleteByNameResponseBodies, CONTENT_TYPE extends never = never>(args?: GroupDeleteByNameRequestParameters): Keq<GroupDeleteByNameOperation<STATUS, CONTENT_TYPE>>;
  entityLookUp<STATUS extends keyof EntityLookUpResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EntityLookUpRequestParameters): Keq<EntityLookUpOperation<STATUS, CONTENT_TYPE>>;
  groupLookUp<STATUS extends keyof GroupLookUpResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GroupLookUpRequestParameters): Keq<GroupLookUpOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List login enforcements
   *
   */
  mfaListLoginEnforcements<STATUS extends keyof MfaListLoginEnforcementsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListLoginEnforcementsRequestParameters): Keq<MfaListLoginEnforcementsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current login enforcement
   *
   */
  mfaReadLoginEnforcement<STATUS extends keyof MfaReadLoginEnforcementResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadLoginEnforcementRequestParameters): Keq<MfaReadLoginEnforcementOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Create or update a login enforcement
   *
   */
  mfaWriteLoginEnforcement<STATUS extends keyof MfaWriteLoginEnforcementResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaWriteLoginEnforcementRequestParameters): Keq<MfaWriteLoginEnforcementOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a login enforcement
   *
   */
  mfaDeleteLoginEnforcement<STATUS extends keyof MfaDeleteLoginEnforcementResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaDeleteLoginEnforcementRequestParameters): Keq<MfaDeleteLoginEnforcementOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List MFA method configurations for all MFA methods
   *
   */
  mfaListMethods<STATUS extends keyof MfaListMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListMethodsRequestParameters): Keq<MfaListMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List MFA method configurations for the given MFA method
   *
   */
  mfaListDuoMethods<STATUS extends keyof MfaListDuoMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListDuoMethodsRequestParameters): Keq<MfaListDuoMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current configuration for the given MFA method
   *
   */
  mfaReadDuoMethodConfiguration<STATUS extends keyof MfaReadDuoMethodConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadDuoMethodConfigurationRequestParameters): Keq<MfaReadDuoMethodConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create a configuration for the given MFA method
   *
   */
  mfaConfigureDuoMethod<STATUS extends keyof MfaConfigureDuoMethodResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaConfigureDuoMethodRequestParameters): Keq<MfaConfigureDuoMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a configuration for the given MFA method
   *
   */
  mfaDeleteDuoMethod<STATUS extends keyof MfaDeleteDuoMethodResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaDeleteDuoMethodRequestParameters): Keq<MfaDeleteDuoMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List MFA method configurations for the given MFA method
   *
   */
  mfaListOktaMethods<STATUS extends keyof MfaListOktaMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListOktaMethodsRequestParameters): Keq<MfaListOktaMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current configuration for the given MFA method
   *
   */
  mfaReadOktaMethodConfiguration<STATUS extends keyof MfaReadOktaMethodConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadOktaMethodConfigurationRequestParameters): Keq<MfaReadOktaMethodConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create a configuration for the given MFA method
   *
   */
  mfaConfigureOktaMethod<STATUS extends keyof MfaConfigureOktaMethodResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaConfigureOktaMethodRequestParameters): Keq<MfaConfigureOktaMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a configuration for the given MFA method
   *
   */
  mfaDeleteOktaMethod<STATUS extends keyof MfaDeleteOktaMethodResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaDeleteOktaMethodRequestParameters): Keq<MfaDeleteOktaMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List MFA method configurations for the given MFA method
   *
   */
  mfaListPingIdMethods<STATUS extends keyof MfaListPingIdMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListPingIdMethodsRequestParameters): Keq<MfaListPingIdMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current configuration for the given MFA method
   *
   */
  mfaReadPingIdMethodConfiguration<STATUS extends keyof MfaReadPingIdMethodConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadPingIdMethodConfigurationRequestParameters): Keq<MfaReadPingIdMethodConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create a configuration for the given MFA method
   *
   */
  mfaConfigurePingIdMethod<STATUS extends keyof MfaConfigurePingIdMethodResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaConfigurePingIdMethodRequestParameters): Keq<MfaConfigurePingIdMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a configuration for the given MFA method
   *
   */
  mfaDeletePingIdMethod<STATUS extends keyof MfaDeletePingIdMethodResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaDeletePingIdMethodRequestParameters): Keq<MfaDeletePingIdMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List MFA method configurations for the given MFA method
   *
   */
  mfaListTotpMethods<STATUS extends keyof MfaListTotpMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaListTotpMethodsRequestParameters): Keq<MfaListTotpMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Destroys a TOTP secret for the given MFA method ID on the given entity
   *
   */
  mfaAdminDestroyTotpSecret<STATUS extends keyof MfaAdminDestroyTotpSecretResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaAdminDestroyTotpSecretRequestParameters): Keq<MfaAdminDestroyTotpSecretOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create TOTP secret for the given method ID on the given entity.
   *
   */
  mfaAdminGenerateTotpSecret<STATUS extends keyof MfaAdminGenerateTotpSecretResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaAdminGenerateTotpSecretRequestParameters): Keq<MfaAdminGenerateTotpSecretOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create TOTP secret for the given method ID on the given entity.
   *
   */
  mfaGenerateTotpSecret<STATUS extends keyof MfaGenerateTotpSecretResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaGenerateTotpSecretRequestParameters): Keq<MfaGenerateTotpSecretOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current configuration for the given MFA method
   *
   */
  mfaReadTotpMethodConfiguration<STATUS extends keyof MfaReadTotpMethodConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadTotpMethodConfigurationRequestParameters): Keq<MfaReadTotpMethodConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Update or create a configuration for the given MFA method
   *
   */
  mfaConfigureTotpMethod<STATUS extends keyof MfaConfigureTotpMethodResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaConfigureTotpMethodRequestParameters): Keq<MfaConfigureTotpMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a configuration for the given MFA method
   *
   */
  mfaDeleteTotpMethod<STATUS extends keyof MfaDeleteTotpMethodResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaDeleteTotpMethodRequestParameters): Keq<MfaDeleteTotpMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the current configuration for the given ID regardless of the MFA method type
   *
   */
  mfaReadMethodConfiguration<STATUS extends keyof MfaReadMethodConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MfaReadMethodConfigurationRequestParameters): Keq<MfaReadMethodConfigurationOperation<STATUS, CONTENT_TYPE>>;
  oidcReadPublicKeys<STATUS extends keyof OidcReadPublicKeysResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadPublicKeysRequestParameters): Keq<OidcReadPublicKeysOperation<STATUS, CONTENT_TYPE>>;
  oidcReadOpenIdConfiguration<STATUS extends keyof OidcReadOpenIdConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadOpenIdConfigurationRequestParameters): Keq<OidcReadOpenIdConfigurationOperation<STATUS, CONTENT_TYPE>>;
  oidcListAssignments<STATUS extends keyof OidcListAssignmentsResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListAssignmentsRequestParameters): Keq<OidcListAssignmentsOperation<STATUS, CONTENT_TYPE>>;
  oidcReadAssignment<STATUS extends keyof OidcReadAssignmentResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadAssignmentRequestParameters): Keq<OidcReadAssignmentOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteAssignment<STATUS extends keyof OidcWriteAssignmentResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteAssignmentRequestParameters): Keq<OidcWriteAssignmentOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteAssignment<STATUS extends keyof OidcDeleteAssignmentResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteAssignmentRequestParameters): Keq<OidcDeleteAssignmentOperation<STATUS, CONTENT_TYPE>>;
  oidcListClients<STATUS extends keyof OidcListClientsResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListClientsRequestParameters): Keq<OidcListClientsOperation<STATUS, CONTENT_TYPE>>;
  oidcReadClient<STATUS extends keyof OidcReadClientResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadClientRequestParameters): Keq<OidcReadClientOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteClient<STATUS extends keyof OidcWriteClientResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteClientRequestParameters): Keq<OidcWriteClientOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteClient<STATUS extends keyof OidcDeleteClientResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteClientRequestParameters): Keq<OidcDeleteClientOperation<STATUS, CONTENT_TYPE>>;
  oidcReadConfiguration<STATUS extends keyof OidcReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadConfigurationRequestParameters): Keq<OidcReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  oidcConfigure<STATUS extends keyof OidcConfigureResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcConfigureRequestParameters): Keq<OidcConfigureOperation<STATUS, CONTENT_TYPE>>;
  oidcIntrospect<STATUS extends keyof OidcIntrospectResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcIntrospectRequestParameters): Keq<OidcIntrospectOperation<STATUS, CONTENT_TYPE>>;
  oidcListKeys<STATUS extends keyof OidcListKeysResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListKeysRequestParameters): Keq<OidcListKeysOperation<STATUS, CONTENT_TYPE>>;
  oidcReadKey<STATUS extends keyof OidcReadKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadKeyRequestParameters): Keq<OidcReadKeyOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteKey<STATUS extends keyof OidcWriteKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteKeyRequestParameters): Keq<OidcWriteKeyOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteKey<STATUS extends keyof OidcDeleteKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteKeyRequestParameters): Keq<OidcDeleteKeyOperation<STATUS, CONTENT_TYPE>>;
  oidcRotateKey<STATUS extends keyof OidcRotateKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcRotateKeyRequestParameters): Keq<OidcRotateKeyOperation<STATUS, CONTENT_TYPE>>;
  oidcListProviders<STATUS extends keyof OidcListProvidersResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListProvidersRequestParameters): Keq<OidcListProvidersOperation<STATUS, CONTENT_TYPE>>;
  oidcReadProvider<STATUS extends keyof OidcReadProviderResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadProviderRequestParameters): Keq<OidcReadProviderOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteProvider<STATUS extends keyof OidcWriteProviderResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteProviderRequestParameters): Keq<OidcWriteProviderOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteProvider<STATUS extends keyof OidcDeleteProviderResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteProviderRequestParameters): Keq<OidcDeleteProviderOperation<STATUS, CONTENT_TYPE>>;
  oidcReadProviderPublicKeys<STATUS extends keyof OidcReadProviderPublicKeysResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadProviderPublicKeysRequestParameters): Keq<OidcReadProviderPublicKeysOperation<STATUS, CONTENT_TYPE>>;
  oidcReadProviderOpenIdConfiguration<STATUS extends keyof OidcReadProviderOpenIdConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadProviderOpenIdConfigurationRequestParameters): Keq<OidcReadProviderOpenIdConfigurationOperation<STATUS, CONTENT_TYPE>>;
  oidcProviderAuthorize<STATUS extends keyof OidcProviderAuthorizeResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcProviderAuthorizeRequestParameters): Keq<OidcProviderAuthorizeOperation<STATUS, CONTENT_TYPE>>;
  oidcProviderAuthorizeWithParameters<STATUS extends keyof OidcProviderAuthorizeWithParametersResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcProviderAuthorizeWithParametersRequestParameters): Keq<OidcProviderAuthorizeWithParametersOperation<STATUS, CONTENT_TYPE>>;
  oidcProviderToken<STATUS extends keyof OidcProviderTokenResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcProviderTokenRequestParameters): Keq<OidcProviderTokenOperation<STATUS, CONTENT_TYPE>>;
  oidcProviderUserInfo<STATUS extends keyof OidcProviderUserInfoResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcProviderUserInfoRequestParameters): Keq<OidcProviderUserInfoOperation<STATUS, CONTENT_TYPE>>;
  oidcListRoles<STATUS extends keyof OidcListRolesResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListRolesRequestParameters): Keq<OidcListRolesOperation<STATUS, CONTENT_TYPE>>;
  oidcReadRole<STATUS extends keyof OidcReadRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadRoleRequestParameters): Keq<OidcReadRoleOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteRole<STATUS extends keyof OidcWriteRoleResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteRoleRequestParameters): Keq<OidcWriteRoleOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteRole<STATUS extends keyof OidcDeleteRoleResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteRoleRequestParameters): Keq<OidcDeleteRoleOperation<STATUS, CONTENT_TYPE>>;
  oidcListScopes<STATUS extends keyof OidcListScopesResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcListScopesRequestParameters): Keq<OidcListScopesOperation<STATUS, CONTENT_TYPE>>;
  oidcReadScope<STATUS extends keyof OidcReadScopeResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcReadScopeRequestParameters): Keq<OidcReadScopeOperation<STATUS, CONTENT_TYPE>>;
  oidcWriteScope<STATUS extends keyof OidcWriteScopeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: OidcWriteScopeRequestParameters): Keq<OidcWriteScopeOperation<STATUS, CONTENT_TYPE>>;
  oidcDeleteScope<STATUS extends keyof OidcDeleteScopeResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcDeleteScopeRequestParameters): Keq<OidcDeleteScopeOperation<STATUS, CONTENT_TYPE>>;
  oidcGenerateToken<STATUS extends keyof OidcGenerateTokenResponseBodies, CONTENT_TYPE extends never = never>(args?: OidcGenerateTokenRequestParameters): Keq<OidcGenerateTokenOperation<STATUS, CONTENT_TYPE>>;
  personaCreate<STATUS extends keyof PersonaCreateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PersonaCreateRequestParameters): Keq<PersonaCreateOperation<STATUS, CONTENT_TYPE>>;
  personaListById<STATUS extends keyof PersonaListByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: PersonaListByIdRequestParameters): Keq<PersonaListByIdOperation<STATUS, CONTENT_TYPE>>;
  personaReadById<STATUS extends keyof PersonaReadByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: PersonaReadByIdRequestParameters): Keq<PersonaReadByIdOperation<STATUS, CONTENT_TYPE>>;
  personaUpdateById<STATUS extends keyof PersonaUpdateByIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PersonaUpdateByIdRequestParameters): Keq<PersonaUpdateByIdOperation<STATUS, CONTENT_TYPE>>;
  personaDeleteById<STATUS extends keyof PersonaDeleteByIdResponseBodies, CONTENT_TYPE extends never = never>(args?: PersonaDeleteByIdRequestParameters): Keq<PersonaDeleteByIdOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the backend level settings.
   *
   */
  kvReadConfig<STATUS extends keyof KvReadConfigResponseBodies, CONTENT_TYPE extends never = never>(args?: KvReadConfigRequestParameters): Keq<KvReadConfigOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Configure backend level settings that are applied to every key in the key-value store.
   *
   */
  kvWriteConfig<STATUS extends keyof KvWriteConfigResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteConfigRequestParameters): Keq<KvWriteConfigOperation<STATUS, CONTENT_TYPE>>;
  kvReadDataPath<STATUS extends keyof KvReadDataPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvReadDataPathRequestParameters): Keq<KvReadDataPathOperation<STATUS, CONTENT_TYPE>>;
  kvWriteDataPath<STATUS extends keyof KvWriteDataPathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteDataPathRequestParameters): Keq<KvWriteDataPathOperation<STATUS, CONTENT_TYPE>>;
  kvDeleteDataPath<STATUS extends keyof KvDeleteDataPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvDeleteDataPathRequestParameters): Keq<KvDeleteDataPathOperation<STATUS, CONTENT_TYPE>>;
  kvWriteDeletePath<STATUS extends keyof KvWriteDeletePathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteDeletePathRequestParameters): Keq<KvWriteDeletePathOperation<STATUS, CONTENT_TYPE>>;
  kvWriteDestroyPath<STATUS extends keyof KvWriteDestroyPathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteDestroyPathRequestParameters): Keq<KvWriteDestroyPathOperation<STATUS, CONTENT_TYPE>>;
  kvListDetailedMetadataPath<STATUS extends keyof KvListDetailedMetadataPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvListDetailedMetadataPathRequestParameters): Keq<KvListDetailedMetadataPathOperation<STATUS, CONTENT_TYPE>>;
  kvReadMetadataPath<STATUS extends keyof KvReadMetadataPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvReadMetadataPathRequestParameters): Keq<KvReadMetadataPathOperation<STATUS, CONTENT_TYPE>>;
  kvWriteMetadataPath<STATUS extends keyof KvWriteMetadataPathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteMetadataPathRequestParameters): Keq<KvWriteMetadataPathOperation<STATUS, CONTENT_TYPE>>;
  kvDeleteMetadataPath<STATUS extends keyof KvDeleteMetadataPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvDeleteMetadataPathRequestParameters): Keq<KvDeleteMetadataPathOperation<STATUS, CONTENT_TYPE>>;
  kvReadSubkeysPath<STATUS extends keyof KvReadSubkeysPathResponseBodies, CONTENT_TYPE extends never = never>(args?: KvReadSubkeysPathRequestParameters): Keq<KvReadSubkeysPathOperation<STATUS, CONTENT_TYPE>>;
  kvWriteUndeletePath<STATUS extends keyof KvWriteUndeletePathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: KvWriteUndeletePathRequestParameters): Keq<KvWriteUndeletePathOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List the enabled audit devices.
   *
   */
  auditingListEnabledDevices<STATUS extends keyof AuditingListEnabledDevicesResponseBodies, CONTENT_TYPE extends never = never>(args?: AuditingListEnabledDevicesRequestParameters): Keq<AuditingListEnabledDevicesOperation<STATUS, CONTENT_TYPE>>;
  auditingCalculateHash<STATUS extends keyof AuditingCalculateHashResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AuditingCalculateHashRequestParameters): Keq<AuditingCalculateHashOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enable a new audit device at the supplied path.
   *
   */
  auditingEnableDevice<STATUS extends keyof AuditingEnableDeviceResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AuditingEnableDeviceRequestParameters): Keq<AuditingEnableDeviceOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Disable the audit device at the given path.
   *
   */
  auditingDisableDevice<STATUS extends keyof AuditingDisableDeviceResponseBodies, CONTENT_TYPE extends never = never>(args?: AuditingDisableDeviceRequestParameters): Keq<AuditingDisableDeviceOperation<STATUS, CONTENT_TYPE>>;
  authListEnabledMethods<STATUS extends keyof AuthListEnabledMethodsResponseBodies, CONTENT_TYPE extends never = never>(args?: AuthListEnabledMethodsRequestParameters): Keq<AuthListEnabledMethodsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration of the auth engine at the given path.
   *
   */
  authReadConfiguration<STATUS extends keyof AuthReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: AuthReadConfigurationRequestParameters): Keq<AuthReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enables a new auth method.
   *
   * @description After enabling, the auth method can be accessed and configured via the auth path specified as part of the URL. This auth path will be nested under the auth prefix.
   *
   * For example, enable the "foo" auth method will make it accessible at /auth/foo.
   */
  authEnableMethod<STATUS extends keyof AuthEnableMethodResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AuthEnableMethodRequestParameters): Keq<AuthEnableMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Disable the auth method at the given auth path
   *
   */
  authDisableMethod<STATUS extends keyof AuthDisableMethodResponseBodies, CONTENT_TYPE extends never = never>(args?: AuthDisableMethodRequestParameters): Keq<AuthDisableMethodOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reads the given auth path's configuration.
   *
   * @description This endpoint requires sudo capability on the final path, but the same functionality can be achieved without sudo via `sys/mounts/auth/[auth-path]/tune`.
   */
  authReadTuningInformation<STATUS extends keyof AuthReadTuningInformationResponseBodies, CONTENT_TYPE extends never = never>(args?: AuthReadTuningInformationRequestParameters): Keq<AuthReadTuningInformationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Tune configuration parameters for a given auth path.
   *
   * @description This endpoint requires sudo capability on the final path, but the same functionality can be achieved without sudo via `sys/mounts/auth/[auth-path]/tune`.
   */
  authTuneConfigurationParameters<STATUS extends keyof AuthTuneConfigurationParametersResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AuthTuneConfigurationParametersRequestParameters): Keq<AuthTuneConfigurationParametersOperation<STATUS, CONTENT_TYPE>>;
  queryTokenCapabilities<STATUS extends keyof QueryTokenCapabilitiesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: QueryTokenCapabilitiesRequestParameters): Keq<QueryTokenCapabilitiesOperation<STATUS, CONTENT_TYPE>>;
  queryTokenAccessorCapabilities<STATUS extends keyof QueryTokenAccessorCapabilitiesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: QueryTokenAccessorCapabilitiesRequestParameters): Keq<QueryTokenAccessorCapabilitiesOperation<STATUS, CONTENT_TYPE>>;
  queryTokenSelfCapabilities<STATUS extends keyof QueryTokenSelfCapabilitiesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: QueryTokenSelfCapabilitiesRequestParameters): Keq<QueryTokenSelfCapabilitiesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List the request headers that are configured to be audited.
   *
   */
  auditingListRequestHeaders<STATUS extends keyof AuditingListRequestHeadersResponseBodies, CONTENT_TYPE extends never = never>(args?: AuditingListRequestHeadersRequestParameters): Keq<AuditingListRequestHeadersOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List the information for the given request header.
   *
   */
  auditingReadRequestHeaderInformation<STATUS extends keyof AuditingReadRequestHeaderInformationResponseBodies, CONTENT_TYPE extends never = never>(args?: AuditingReadRequestHeaderInformationRequestParameters): Keq<AuditingReadRequestHeaderInformationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enable auditing of a header.
   *
   */
  auditingEnableRequestHeader<STATUS extends keyof AuditingEnableRequestHeaderResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: AuditingEnableRequestHeaderRequestParameters): Keq<AuditingEnableRequestHeaderOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Disable auditing of the given request header.
   *
   */
  auditingDisableRequestHeader<STATUS extends keyof AuditingDisableRequestHeaderResponseBodies, CONTENT_TYPE extends never = never>(args?: AuditingDisableRequestHeaderRequestParameters): Keq<AuditingDisableRequestHeaderOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the current CORS settings.
   *
   */
  corsReadConfiguration<STATUS extends keyof CorsReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: CorsReadConfigurationRequestParameters): Keq<CorsReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Configure the CORS settings.
   *
   */
  corsConfigure<STATUS extends keyof CorsConfigureResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: CorsConfigureRequestParameters): Keq<CorsConfigureOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Remove any CORS settings.
   *
   */
  corsDeleteConfiguration<STATUS extends keyof CorsDeleteConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: CorsDeleteConfigurationRequestParameters): Keq<CorsDeleteConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reload the given subsystem
   *
   */
  reloadSubsystem<STATUS extends keyof ReloadSubsystemResponseBodies, CONTENT_TYPE extends never = never>(args?: ReloadSubsystemRequestParameters): Keq<ReloadSubsystemOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return a sanitized version of the OpenBao server configuration.
   *
   * @description The sanitized output strips configuration values in the storage, HA storage, and seals stanzas, which may contain sensitive values such as API tokens. It also removes any token or secret fields in other stanzas, such as the circonus_api_token from telemetry.
   */
  readSanitizedConfigurationState<STATUS extends keyof ReadSanitizedConfigurationStateResponseBodies, CONTENT_TYPE extends never = never>(args?: ReadSanitizedConfigurationStateRequestParameters): Keq<ReadSanitizedConfigurationStateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return a list of configured UI headers.
   *
   */
  uiHeadersList<STATUS extends keyof UiHeadersListResponseBodies, CONTENT_TYPE extends never = never>(args?: UiHeadersListRequestParameters): Keq<UiHeadersListOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the given UI header's configuration
   *
   */
  uiHeadersReadConfiguration<STATUS extends keyof UiHeadersReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: UiHeadersReadConfigurationRequestParameters): Keq<UiHeadersReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Configure the values to be returned for the UI header.
   *
   */
  uiHeadersConfigure<STATUS extends keyof UiHeadersConfigureResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UiHeadersConfigureRequestParameters): Keq<UiHeadersConfigureOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Remove a UI header.
   *
   */
  uiHeadersDeleteConfiguration<STATUS extends keyof UiHeadersDeleteConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: UiHeadersDeleteConfigurationRequestParameters): Keq<UiHeadersDeleteConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Decodes the encoded token with the otp.
   *
   */
  decode<STATUS extends keyof DecodeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: DecodeRequestParameters): Keq<DecodeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration and progress of the current root generation attempt.
   *
   */
  rootTokenGenerationReadProgress2<STATUS extends keyof RootTokenGenerationReadProgress2ResponseBodies, CONTENT_TYPE extends never = never>(args?: RootTokenGenerationReadProgress2RequestParameters): Keq<RootTokenGenerationReadProgress2Operation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration and progress of the current root generation attempt.
   *
   */
  rootTokenGenerationReadProgress<STATUS extends keyof RootTokenGenerationReadProgressResponseBodies, CONTENT_TYPE extends never = never>(args?: RootTokenGenerationReadProgressRequestParameters): Keq<RootTokenGenerationReadProgressOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initializes a new root generation attempt.
   *
   * @description Only a single root generation attempt can take place at a time. One (and only one) of otp or pgp_key are required.
   */
  rootTokenGenerationInitialize<STATUS extends keyof RootTokenGenerationInitializeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RootTokenGenerationInitializeRequestParameters): Keq<RootTokenGenerationInitializeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancels any in-progress root generation attempt.
   *
   */
  rootTokenGenerationCancel<STATUS extends keyof RootTokenGenerationCancelResponseBodies, CONTENT_TYPE extends never = never>(args?: RootTokenGenerationCancelRequestParameters): Keq<RootTokenGenerationCancelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single unseal key share to progress the root generation attempt.
   *
   * @description If the threshold number of unseal key shares is reached, OpenBao will complete the root generation and issue the new token. Otherwise, this API must be called multiple times until that threshold is met. The attempt nonce must be provided with each call.
   */
  rootTokenGenerationUpdate<STATUS extends keyof RootTokenGenerationUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RootTokenGenerationUpdateRequestParameters): Keq<RootTokenGenerationUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Check the HA status of an OpenBao cluster
   *
   */
  haStatus<STATUS extends keyof HaStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: HaStatusRequestParameters): Keq<HaStatusOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Returns the health status of OpenBao.
   *
   */
  readHealthStatus<STATUS extends keyof ReadHealthStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: ReadHealthStatusRequestParameters): Keq<ReadHealthStatusOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Information about the host instance that this OpenBao server is running on.
   *
   * @description Information about the host instance that this OpenBao server is running on.
   *     The information that gets collected includes host hardware information, and CPU,
   *     disk, and memory utilization
   */
  collectHostInformation<STATUS extends keyof CollectHostInformationResponseBodies, CONTENT_TYPE extends never = never>(args?: CollectHostInformationRequestParameters): Keq<CollectHostInformationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * reports in-flight requests
   *
   * @description This path responds to the following HTTP methods.
   *     GET /
   *       Returns a map of in-flight requests.
   */
  collectInFlightRequestInformation<STATUS extends keyof CollectInFlightRequestInformationResponseBodies, CONTENT_TYPE extends never = never>(args?: CollectInFlightRequestInformationRequestParameters): Keq<CollectInFlightRequestInformationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Returns the initialization status of OpenBao.
   *
   */
  readInitializationStatus<STATUS extends keyof ReadInitializationStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: ReadInitializationStatusRequestParameters): Keq<ReadInitializationStatusOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initialize a new OpenBao instance.
   *
   * @description The OpenBao instance must not have been previously initialized. The recovery options, as well as the stored shares option, are only available when using OpenBao HSM.
   */
  initializeSystem<STATUS extends keyof InitializeSystemResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: InitializeSystemRequestParameters): Keq<InitializeSystemOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyStatus<STATUS extends keyof EncryptionKeyStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: EncryptionKeyStatusRequestParameters): Keq<EncryptionKeyStatusOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Returns the high availability status and current leader instance of OpenBao.
   *
   */
  leaderStatus<STATUS extends keyof LeaderStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: LeaderStatusRequestParameters): Keq<LeaderStatusOperation<STATUS, CONTENT_TYPE>>;
  leasesList<STATUS extends keyof LeasesListResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesListRequestParameters): Keq<LeasesListOperation<STATUS, CONTENT_TYPE>>;
  leasesCount<STATUS extends keyof LeasesCountResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesCountRequestParameters): Keq<LeasesCountOperation<STATUS, CONTENT_TYPE>>;
  leasesReadLease<STATUS extends keyof LeasesReadLeaseResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesReadLeaseRequestParameters): Keq<LeasesReadLeaseOperation<STATUS, CONTENT_TYPE>>;
  leasesLookUp<STATUS extends keyof LeasesLookUpResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesLookUpRequestParameters): Keq<LeasesLookUpOperation<STATUS, CONTENT_TYPE>>;
  leasesLookUpWithPrefix<STATUS extends keyof LeasesLookUpWithPrefixResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesLookUpWithPrefixRequestParameters): Keq<LeasesLookUpWithPrefixOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Renews a lease, requesting to extend the lease.
   *
   */
  leasesRenewLease<STATUS extends keyof LeasesRenewLeaseResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesRenewLeaseRequestParameters): Keq<LeasesRenewLeaseOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Renews a lease, requesting to extend the lease.
   *
   */
  leasesRenewLeaseWithId<STATUS extends keyof LeasesRenewLeaseWithIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesRenewLeaseWithIdRequestParameters): Keq<LeasesRenewLeaseWithIdOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revokes a lease immediately.
   *
   */
  leasesRevokeLease<STATUS extends keyof LeasesRevokeLeaseResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesRevokeLeaseRequestParameters): Keq<LeasesRevokeLeaseOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revokes all secrets or tokens generated under a given prefix immediately
   *
   * @description Unlike `/sys/leases/revoke-prefix`, this path ignores backend errors encountered during revocation. This is potentially very dangerous and should only be used in specific emergency situations where errors in the backend or the connected backend service prevent normal revocation.
   *
   * By ignoring these errors, OpenBao abdicates responsibility for ensuring that the issued credentials or secrets are properly revoked and/or cleaned up. Access to this endpoint should be tightly controlled.
   */
  leasesForceRevokeLeaseWithPrefix<STATUS extends keyof LeasesForceRevokeLeaseWithPrefixResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesForceRevokeLeaseWithPrefixRequestParameters): Keq<LeasesForceRevokeLeaseWithPrefixOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revokes all secrets (via a lease ID prefix) or tokens (via the tokens' path property) generated under a given prefix immediately.
   *
   */
  leasesRevokeLeaseWithPrefix<STATUS extends keyof LeasesRevokeLeaseWithPrefixResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesRevokeLeaseWithPrefixRequestParameters): Keq<LeasesRevokeLeaseWithPrefixOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revokes a lease immediately.
   *
   */
  leasesRevokeLeaseWithId<STATUS extends keyof LeasesRevokeLeaseWithIdResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LeasesRevokeLeaseWithIdRequestParameters): Keq<LeasesRevokeLeaseWithIdOperation<STATUS, CONTENT_TYPE>>;
  leasesTidy<STATUS extends keyof LeasesTidyResponseBodies, CONTENT_TYPE extends never = never>(args?: LeasesTidyRequestParameters): Keq<LeasesTidyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Report the locked user count metrics, for this namespace and all child namespaces.
   *
   */
  lockedUsersList<STATUS extends keyof LockedUsersListResponseBodies, CONTENT_TYPE extends never = never>(args?: LockedUsersListRequestParameters): Keq<LockedUsersListOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Unlocks the user with given mount_accessor and alias_identifier
   *
   */
  lockedUsersUnlock<STATUS extends keyof LockedUsersUnlockResponseBodies, CONTENT_TYPE extends never = never>(args?: LockedUsersUnlockRequestParameters): Keq<LockedUsersUnlockOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the log level for all existing loggers.
   *
   */
  loggersReadVerbosityLevel<STATUS extends keyof LoggersReadVerbosityLevelResponseBodies, CONTENT_TYPE extends never = never>(args?: LoggersReadVerbosityLevelRequestParameters): Keq<LoggersReadVerbosityLevelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Modify the log level for all existing loggers.
   *
   */
  loggersUpdateVerbosityLevel<STATUS extends keyof LoggersUpdateVerbosityLevelResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LoggersUpdateVerbosityLevelRequestParameters): Keq<LoggersUpdateVerbosityLevelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revert the all loggers to use log level provided in config.
   *
   */
  loggersRevertVerbosityLevel<STATUS extends keyof LoggersRevertVerbosityLevelResponseBodies, CONTENT_TYPE extends never = never>(args?: LoggersRevertVerbosityLevelRequestParameters): Keq<LoggersRevertVerbosityLevelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the log level for a single logger.
   *
   */
  loggersReadVerbosityLevelFor<STATUS extends keyof LoggersReadVerbosityLevelForResponseBodies, CONTENT_TYPE extends never = never>(args?: LoggersReadVerbosityLevelForRequestParameters): Keq<LoggersReadVerbosityLevelForOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Modify the log level of a single logger.
   *
   */
  loggersUpdateVerbosityLevelFor<STATUS extends keyof LoggersUpdateVerbosityLevelForResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: LoggersUpdateVerbosityLevelForRequestParameters): Keq<LoggersUpdateVerbosityLevelForOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Revert a single logger to use log level provided in config.
   *
   */
  loggersRevertVerbosityLevelFor<STATUS extends keyof LoggersRevertVerbosityLevelForResponseBodies, CONTENT_TYPE extends never = never>(args?: LoggersRevertVerbosityLevelForRequestParameters): Keq<LoggersRevertVerbosityLevelForOperation<STATUS, CONTENT_TYPE>>;
  metrics<STATUS extends keyof MetricsResponseBodies, CONTENT_TYPE extends never = never>(args?: MetricsRequestParameters): Keq<MetricsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Validates the login for the given MFA methods. Upon successful validation, it returns an auth response containing the client token
   *
   */
  mfaValidate<STATUS extends keyof MfaValidateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MfaValidateRequestParameters): Keq<MfaValidateOperation<STATUS, CONTENT_TYPE>>;
  monitor<STATUS extends keyof MonitorResponseBodies, CONTENT_TYPE extends never = never>(args?: MonitorRequestParameters): Keq<MonitorOperation<STATUS, CONTENT_TYPE>>;
  mountsListSecretsEngines<STATUS extends keyof MountsListSecretsEnginesResponseBodies, CONTENT_TYPE extends never = never>(args?: MountsListSecretsEnginesRequestParameters): Keq<MountsListSecretsEnginesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration of the secret engine at the given path.
   *
   */
  mountsReadConfiguration<STATUS extends keyof MountsReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: MountsReadConfigurationRequestParameters): Keq<MountsReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enable a new secrets engine at the given path.
   *
   */
  mountsEnableSecretsEngine<STATUS extends keyof MountsEnableSecretsEngineResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MountsEnableSecretsEngineRequestParameters): Keq<MountsEnableSecretsEngineOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Disable the mount point specified at the given path.
   *
   */
  mountsDisableSecretsEngine<STATUS extends keyof MountsDisableSecretsEngineResponseBodies, CONTENT_TYPE extends never = never>(args?: MountsDisableSecretsEngineRequestParameters): Keq<MountsDisableSecretsEngineOperation<STATUS, CONTENT_TYPE>>;
  mountsReadTuningInformation<STATUS extends keyof MountsReadTuningInformationResponseBodies, CONTENT_TYPE extends never = never>(args?: MountsReadTuningInformationRequestParameters): Keq<MountsReadTuningInformationOperation<STATUS, CONTENT_TYPE>>;
  mountsTuneConfigurationParameters<STATUS extends keyof MountsTuneConfigurationParametersResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: MountsTuneConfigurationParametersRequestParameters): Keq<MountsTuneConfigurationParametersOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List namespaces.
   *
   */
  namespacesListNamespaces<STATUS extends keyof NamespacesListNamespacesResponseBodies, CONTENT_TYPE extends never = never>(args?: NamespacesListNamespacesRequestParameters): Keq<NamespacesListNamespacesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Lock a namespace.
   *
   */
  namespacesWriteNamespacesApiLockLock<STATUS extends keyof NamespacesWriteNamespacesApiLockLockResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: NamespacesWriteNamespacesApiLockLockRequestParameters): Keq<NamespacesWriteNamespacesApiLockLockOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Lock a namespace.
   *
   */
  namespacesWriteNamespacesApiLockLockPath<STATUS extends keyof NamespacesWriteNamespacesApiLockLockPathResponseBodies, CONTENT_TYPE extends never = never>(args?: NamespacesWriteNamespacesApiLockLockPathRequestParameters): Keq<NamespacesWriteNamespacesApiLockLockPathOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Unlock a namespace.
   *
   */
  namespacesWriteNamespacesApiLockUnlock<STATUS extends keyof NamespacesWriteNamespacesApiLockUnlockResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: NamespacesWriteNamespacesApiLockUnlockRequestParameters): Keq<NamespacesWriteNamespacesApiLockUnlockOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Unlock a namespace.
   *
   */
  namespacesWriteNamespacesApiLockUnlockPath<STATUS extends keyof NamespacesWriteNamespacesApiLockUnlockPathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: NamespacesWriteNamespacesApiLockUnlockPathRequestParameters): Keq<NamespacesWriteNamespacesApiLockUnlockPathOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Retrieve a namespace.
   *
   */
  namespacesReadNamespacesPath<STATUS extends keyof NamespacesReadNamespacesPathResponseBodies, CONTENT_TYPE extends never = never>(args?: NamespacesReadNamespacesPathRequestParameters): Keq<NamespacesReadNamespacesPathOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Create or update a namespace.
   *
   */
  namespacesWriteNamespacesPath<STATUS extends keyof NamespacesWriteNamespacesPathResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: NamespacesWriteNamespacesPathRequestParameters): Keq<NamespacesWriteNamespacesPathOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a namespace.
   *
   */
  namespacesDeleteNamespacesPath<STATUS extends keyof NamespacesDeleteNamespacesPathResponseBodies, CONTENT_TYPE extends never = never>(args?: NamespacesDeleteNamespacesPathRequestParameters): Keq<NamespacesDeleteNamespacesPathOperation<STATUS, CONTENT_TYPE>>;
  pluginsCatalogListPlugins<STATUS extends keyof PluginsCatalogListPluginsResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogListPluginsRequestParameters): Keq<PluginsCatalogListPluginsOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the configuration data for the plugin with the given name.
   *
   */
  pluginsCatalogReadPluginConfiguration<STATUS extends keyof PluginsCatalogReadPluginConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogReadPluginConfigurationRequestParameters): Keq<PluginsCatalogReadPluginConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Register a new plugin, or updates an existing one with the supplied name.
   *
   */
  pluginsCatalogRegisterPlugin<STATUS extends keyof PluginsCatalogRegisterPluginResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PluginsCatalogRegisterPluginRequestParameters): Keq<PluginsCatalogRegisterPluginOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Remove the plugin with the given name.
   *
   */
  pluginsCatalogRemovePlugin<STATUS extends keyof PluginsCatalogRemovePluginResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogRemovePluginRequestParameters): Keq<PluginsCatalogRemovePluginOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List the plugins in the catalog.
   *
   */
  pluginsCatalogListPluginsWithType<STATUS extends keyof PluginsCatalogListPluginsWithTypeResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogListPluginsWithTypeRequestParameters): Keq<PluginsCatalogListPluginsWithTypeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the configuration data for the plugin with the given name.
   *
   */
  pluginsCatalogReadPluginConfigurationWithType<STATUS extends keyof PluginsCatalogReadPluginConfigurationWithTypeResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogReadPluginConfigurationWithTypeRequestParameters): Keq<PluginsCatalogReadPluginConfigurationWithTypeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Register a new plugin, or updates an existing one with the supplied name.
   *
   */
  pluginsCatalogRegisterPluginWithType<STATUS extends keyof PluginsCatalogRegisterPluginWithTypeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PluginsCatalogRegisterPluginWithTypeRequestParameters): Keq<PluginsCatalogRegisterPluginWithTypeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Remove the plugin with the given name.
   *
   */
  pluginsCatalogRemovePluginWithType<STATUS extends keyof PluginsCatalogRemovePluginWithTypeResponseBodies, CONTENT_TYPE extends never = never>(args?: PluginsCatalogRemovePluginWithTypeRequestParameters): Keq<PluginsCatalogRemovePluginWithTypeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reload mounted plugin backends.
   *
   * @description Either the plugin name (`plugin`) or the desired plugin backend mounts (`mounts`) must be provided, but not both. In the case that the plugin name is provided, all mounted paths that use that plugin backend will be reloaded.  If (`scope`) is provided and is (`global`), the plugin(s) are reloaded globally.
   */
  pluginsReloadBackends<STATUS extends keyof PluginsReloadBackendsResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PluginsReloadBackendsRequestParameters): Keq<PluginsReloadBackendsOperation<STATUS, CONTENT_TYPE>>;
  policiesListAclPolicies<STATUS extends keyof PoliciesListAclPoliciesResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesListAclPoliciesRequestParameters): Keq<PoliciesListAclPoliciesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Retrieve information about the named ACL policy.
   *
   */
  policiesReadAclPolicy<STATUS extends keyof PoliciesReadAclPolicyResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesReadAclPolicyRequestParameters): Keq<PoliciesReadAclPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Add a new or update an existing ACL policy.
   *
   */
  policiesWriteAclPolicy<STATUS extends keyof PoliciesWriteAclPolicyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PoliciesWriteAclPolicyRequestParameters): Keq<PoliciesWriteAclPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete the ACL policy with the given name.
   *
   */
  policiesDeleteAclPolicy<STATUS extends keyof PoliciesDeleteAclPolicyResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesDeleteAclPolicyRequestParameters): Keq<PoliciesDeleteAclPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List ACL policies with detailed information.
   *
   */
  systemListPoliciesDetailedAcl<STATUS extends keyof SystemListPoliciesDetailedAclResponseBodies, CONTENT_TYPE extends never = never>(args?: SystemListPoliciesDetailedAclRequestParameters): Keq<SystemListPoliciesDetailedAclOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List ACL policies with detailed information.
   *
   */
  systemListPoliciesDetailedAclName<STATUS extends keyof SystemListPoliciesDetailedAclNameResponseBodies, CONTENT_TYPE extends never = never>(args?: SystemListPoliciesDetailedAclNameRequestParameters): Keq<SystemListPoliciesDetailedAclNameOperation<STATUS, CONTENT_TYPE>>;
  /**
   * List the existing password policies.
   *
   */
  policiesListPasswordPolicies<STATUS extends keyof PoliciesListPasswordPoliciesResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesListPasswordPoliciesRequestParameters): Keq<PoliciesListPasswordPoliciesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Retrieve an existing password policy.
   *
   */
  policiesReadPasswordPolicy<STATUS extends keyof PoliciesReadPasswordPolicyResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesReadPasswordPolicyRequestParameters): Keq<PoliciesReadPasswordPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Add a new or update an existing password policy.
   *
   */
  policiesWritePasswordPolicy<STATUS extends keyof PoliciesWritePasswordPolicyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: PoliciesWritePasswordPolicyRequestParameters): Keq<PoliciesWritePasswordPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete a password policy.
   *
   */
  policiesDeletePasswordPolicy<STATUS extends keyof PoliciesDeletePasswordPolicyResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesDeletePasswordPolicyRequestParameters): Keq<PoliciesDeletePasswordPolicyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Generate a password from an existing password policy.
   *
   */
  policiesGeneratePasswordFromPasswordPolicy<STATUS extends keyof PoliciesGeneratePasswordFromPasswordPolicyResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesGeneratePasswordFromPasswordPolicyRequestParameters): Keq<PoliciesGeneratePasswordFromPasswordPolicyOperation<STATUS, CONTENT_TYPE>>;
  policiesList<STATUS extends keyof PoliciesListResponseBodies, CONTENT_TYPE extends never = never>(args?: PoliciesListRequestParameters): Keq<PoliciesListOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasReadConfiguration<STATUS extends keyof RateLimitQuotasReadConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: RateLimitQuotasReadConfigurationRequestParameters): Keq<RateLimitQuotasReadConfigurationOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasConfigure<STATUS extends keyof RateLimitQuotasConfigureResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RateLimitQuotasConfigureRequestParameters): Keq<RateLimitQuotasConfigureOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasList<STATUS extends keyof RateLimitQuotasListResponseBodies, CONTENT_TYPE extends never = never>(args?: RateLimitQuotasListRequestParameters): Keq<RateLimitQuotasListOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasRead<STATUS extends keyof RateLimitQuotasReadResponseBodies, CONTENT_TYPE extends never = never>(args?: RateLimitQuotasReadRequestParameters): Keq<RateLimitQuotasReadOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasWrite<STATUS extends keyof RateLimitQuotasWriteResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RateLimitQuotasWriteRequestParameters): Keq<RateLimitQuotasWriteOperation<STATUS, CONTENT_TYPE>>;
  rateLimitQuotasDelete<STATUS extends keyof RateLimitQuotasDeleteResponseBodies, CONTENT_TYPE extends never = never>(args?: RateLimitQuotasDeleteRequestParameters): Keq<RateLimitQuotasDeleteOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the backup copy of PGP-encrypted unseal keys.
   *
   */
  rekeyReadBackupKey<STATUS extends keyof RekeyReadBackupKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyReadBackupKeyRequestParameters): Keq<RekeyReadBackupKeyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete the backup copy of PGP-encrypted unseal keys.
   *
   */
  rekeyDeleteBackupKey<STATUS extends keyof RekeyDeleteBackupKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyDeleteBackupKeyRequestParameters): Keq<RekeyDeleteBackupKeyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reads the configuration and progress of the current rekey attempt.
   *
   */
  rekeyAttemptReadProgress<STATUS extends keyof RekeyAttemptReadProgressResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyAttemptReadProgressRequestParameters): Keq<RekeyAttemptReadProgressOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initializes a new rekey attempt.
   *
   * @description Only a single rekey attempt can take place at a time, and changing the parameters of a rekey requires canceling and starting a new rekey, which will also provide a new nonce.
   */
  rekeyAttemptInitialize<STATUS extends keyof RekeyAttemptInitializeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RekeyAttemptInitializeRequestParameters): Keq<RekeyAttemptInitializeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancels any in-progress rekey.
   *
   * @description This clears the rekey settings as well as any progress made. This must be called to change the parameters of the rekey. Note: verification is still a part of a rekey. If rekeying is canceled during the verification flow, the current unseal keys remain valid.
   */
  rekeyAttemptCancel<STATUS extends keyof RekeyAttemptCancelResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyAttemptCancelRequestParameters): Keq<RekeyAttemptCancelOperation<STATUS, CONTENT_TYPE>>;
  rekeyReadBackupRecoveryKey<STATUS extends keyof RekeyReadBackupRecoveryKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyReadBackupRecoveryKeyRequestParameters): Keq<RekeyReadBackupRecoveryKeyOperation<STATUS, CONTENT_TYPE>>;
  rekeyDeleteBackupRecoveryKey<STATUS extends keyof RekeyDeleteBackupRecoveryKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyDeleteBackupRecoveryKeyRequestParameters): Keq<RekeyDeleteBackupRecoveryKeyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single unseal key share to progress the rekey of the OpenBao.
   *
   */
  rekeyAttemptUpdate<STATUS extends keyof RekeyAttemptUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RekeyAttemptUpdateRequestParameters): Keq<RekeyAttemptUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration and progress of the current rekey verification attempt.
   *
   */
  rekeyVerificationReadProgress<STATUS extends keyof RekeyVerificationReadProgressResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyVerificationReadProgressRequestParameters): Keq<RekeyVerificationReadProgressOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single new key share to progress the rekey verification operation.
   *
   */
  rekeyVerificationUpdate<STATUS extends keyof RekeyVerificationUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RekeyVerificationUpdateRequestParameters): Keq<RekeyVerificationUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancel any in-progress rekey verification operation.
   *
   * @description This clears any progress made and resets the nonce. Unlike a `DELETE` against `sys/rekey/init`, this only resets the current verification operation, not the entire rekey atttempt.
   */
  rekeyVerificationCancel<STATUS extends keyof RekeyVerificationCancelResponseBodies, CONTENT_TYPE extends never = never>(args?: RekeyVerificationCancelRequestParameters): Keq<RekeyVerificationCancelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initiate a mount migration
   *
   */
  remount<STATUS extends keyof RemountResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RemountRequestParameters): Keq<RemountOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Check status of a mount migration
   *
   */
  remountStatus<STATUS extends keyof RemountStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: RemountStatusRequestParameters): Keq<RemountStatusOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyRotate<STATUS extends keyof EncryptionKeyRotateResponseBodies, CONTENT_TYPE extends never = never>(args?: EncryptionKeyRotateRequestParameters): Keq<EncryptionKeyRotateOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyReadRotationConfiguration<STATUS extends keyof EncryptionKeyReadRotationConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: EncryptionKeyReadRotationConfigurationRequestParameters): Keq<EncryptionKeyReadRotationConfigurationOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyConfigureRotationConfiguration<STATUS extends keyof EncryptionKeyConfigureRotationConfigurationResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EncryptionKeyConfigureRotationConfigurationRequestParameters): Keq<EncryptionKeyConfigureRotationConfigurationOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyRotateRotateKeyring<STATUS extends keyof EncryptionKeyRotateRotateKeyringResponseBodies, CONTENT_TYPE extends never = never>(args?: EncryptionKeyRotateRotateKeyringRequestParameters): Keq<EncryptionKeyRotateRotateKeyringOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyReadRotateKeyringConfig<STATUS extends keyof EncryptionKeyReadRotateKeyringConfigResponseBodies, CONTENT_TYPE extends never = never>(args?: EncryptionKeyReadRotateKeyringConfigRequestParameters): Keq<EncryptionKeyReadRotateKeyringConfigOperation<STATUS, CONTENT_TYPE>>;
  encryptionKeyConfigureRotateKeyringConfig<STATUS extends keyof EncryptionKeyConfigureRotateKeyringConfigResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: EncryptionKeyConfigureRotateKeyringConfigRequestParameters): Keq<EncryptionKeyConfigureRotateKeyringConfigOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the backup copy of PGP-encrypted unseal keys.
   *
   */
  rotateReadRotateRecoveryBackup<STATUS extends keyof RotateReadRotateRecoveryBackupResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateReadRotateRecoveryBackupRequestParameters): Keq<RotateReadRotateRecoveryBackupOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete the backup copy of PGP-encrypted unseal keys.
   *
   */
  rotateDeleteRotateRecoveryBackup<STATUS extends keyof RotateDeleteRotateRecoveryBackupResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateDeleteRotateRecoveryBackupRequestParameters): Keq<RotateDeleteRotateRecoveryBackupOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reads the configuration and progress of the current root rotate attempt.
   *
   */
  rotateAttemptReadRotateRecoveryInit<STATUS extends keyof RotateAttemptReadRotateRecoveryInitResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateAttemptReadRotateRecoveryInitRequestParameters): Keq<RotateAttemptReadRotateRecoveryInitOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initializes a new root rotate attempt.
   *
   * @description Only a single rotate attempt can take place at a time, and changing the parameters of a rotate requires canceling and starting a new rotation, which will also provide a new nonce.
   */
  rotateAttemptInitializeRotateRecoveryInit<STATUS extends keyof RotateAttemptInitializeRotateRecoveryInitResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateAttemptInitializeRotateRecoveryInitRequestParameters): Keq<RotateAttemptInitializeRotateRecoveryInitOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancels any in-progress rotate root operation.
   *
   * @description This clears the rotate settings as well as any progress made. This must be called to change the parameters of the rotate. Note: verification is still a part of a rotate. If rotating is canceled during the verification flow, the current unseal keys remain valid.
   */
  rotateAttemptCancelRotateRecoveryInit<STATUS extends keyof RotateAttemptCancelRotateRecoveryInitResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateAttemptCancelRotateRecoveryInitRequestParameters): Keq<RotateAttemptCancelRotateRecoveryInitOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single unseal key share to progress the rotation of the root key of OpenBao.
   *
   */
  rotateAttemptUpdateRotateRecoveryUpdate<STATUS extends keyof RotateAttemptUpdateRotateRecoveryUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateAttemptUpdateRotateRecoveryUpdateRequestParameters): Keq<RotateAttemptUpdateRotateRecoveryUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration and progress of the current rotate verification attempt.
   *
   */
  rotateVerificationReadRotateRecoveryVerify<STATUS extends keyof RotateVerificationReadRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateVerificationReadRotateRecoveryVerifyRequestParameters): Keq<RotateVerificationReadRotateRecoveryVerifyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single new key share to progress the rotation verification operation.
   *
   */
  rotateVerificationUpdateRotateRecoveryVerify<STATUS extends keyof RotateVerificationUpdateRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateVerificationUpdateRotateRecoveryVerifyRequestParameters): Keq<RotateVerificationUpdateRotateRecoveryVerifyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancel any in-progress rotate verification operation.
   *
   * @description This clears any progress made and resets the nonce. Unlike a `DELETE` against `sys/rotate/(root/recovery)/init`, this only resets the current verification operation, not the entire rotate atttempt.
   */
  rotateVerificationCancelRotateRecoveryVerify<STATUS extends keyof RotateVerificationCancelRotateRecoveryVerifyResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateVerificationCancelRotateRecoveryVerifyRequestParameters): Keq<RotateVerificationCancelRotateRecoveryVerifyOperation<STATUS, CONTENT_TYPE>>;
  rootKeyRotate<STATUS extends keyof RootKeyRotateResponseBodies, CONTENT_TYPE extends never = never>(args?: RootKeyRotateRequestParameters): Keq<RootKeyRotateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Return the backup copy of PGP-encrypted unseal keys.
   *
   */
  rotateReadBackupKey<STATUS extends keyof RotateReadBackupKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateReadBackupKeyRequestParameters): Keq<RotateReadBackupKeyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Delete the backup copy of PGP-encrypted unseal keys.
   *
   */
  rotateDeleteBackupKey<STATUS extends keyof RotateDeleteBackupKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateDeleteBackupKeyRequestParameters): Keq<RotateDeleteBackupKeyOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Reads the configuration and progress of the current root rotate attempt.
   *
   */
  rotateAttemptReadProgress<STATUS extends keyof RotateAttemptReadProgressResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateAttemptReadProgressRequestParameters): Keq<RotateAttemptReadProgressOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Initializes a new root rotate attempt.
   *
   * @description Only a single rotate attempt can take place at a time, and changing the parameters of a rotate requires canceling and starting a new rotation, which will also provide a new nonce.
   */
  rotateAttemptInitialize<STATUS extends keyof RotateAttemptInitializeResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateAttemptInitializeRequestParameters): Keq<RotateAttemptInitializeOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancels any in-progress rotate root operation.
   *
   * @description This clears the rotate settings as well as any progress made. This must be called to change the parameters of the rotate. Note: verification is still a part of a rotate. If rotating is canceled during the verification flow, the current unseal keys remain valid.
   */
  rotateAttemptCancel<STATUS extends keyof RotateAttemptCancelResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateAttemptCancelRequestParameters): Keq<RotateAttemptCancelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single unseal key share to progress the rotation of the root key of OpenBao.
   *
   */
  rotateAttemptUpdate<STATUS extends keyof RotateAttemptUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateAttemptUpdateRequestParameters): Keq<RotateAttemptUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Read the configuration and progress of the current rotate verification attempt.
   *
   */
  rotateVerificationReadProgress<STATUS extends keyof RotateVerificationReadProgressResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateVerificationReadProgressRequestParameters): Keq<RotateVerificationReadProgressOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Enter a single new key share to progress the rotation verification operation.
   *
   */
  rotateVerificationUpdate<STATUS extends keyof RotateVerificationUpdateResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RotateVerificationUpdateRequestParameters): Keq<RotateVerificationUpdateOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cancel any in-progress rotate verification operation.
   *
   * @description This clears any progress made and resets the nonce. Unlike a `DELETE` against `sys/rotate/(root/recovery)/init`, this only resets the current verification operation, not the entire rotate atttempt.
   */
  rotateVerificationCancel<STATUS extends keyof RotateVerificationCancelResponseBodies, CONTENT_TYPE extends never = never>(args?: RotateVerificationCancelRequestParameters): Keq<RotateVerificationCancelOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Seal the OpenBao instance.
   *
   */
  seal<STATUS extends keyof SealResponseBodies, CONTENT_TYPE extends never = never>(args?: SealRequestParameters): Keq<SealOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Check the seal status of an OpenBao instance.
   *
   */
  sealStatus<STATUS extends keyof SealStatusResponseBodies, CONTENT_TYPE extends never = never>(args?: SealStatusRequestParameters): Keq<SealStatusOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Cause the node to give up active status.
   *
   * @description This endpoint forces the node to give up active status. If the node does not have active status, this endpoint does nothing. Note that the node will sleep for ten seconds before attempting to grab the active lock again, but if no standby nodes grab the active lock in the interim, the same node may become the active node again.
   */
  stepDownLeader<STATUS extends keyof StepDownLeaderResponseBodies, CONTENT_TYPE extends never = never>(args?: StepDownLeaderRequestParameters): Keq<StepDownLeaderOperation<STATUS, CONTENT_TYPE>>;
  generateHash<STATUS extends keyof GenerateHashResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateHashRequestParameters): Keq<GenerateHashOperation<STATUS, CONTENT_TYPE>>;
  generateHashWithAlgorithm<STATUS extends keyof GenerateHashWithAlgorithmResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateHashWithAlgorithmRequestParameters): Keq<GenerateHashWithAlgorithmOperation<STATUS, CONTENT_TYPE>>;
  generateRandom<STATUS extends keyof GenerateRandomResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateRandomRequestParameters): Keq<GenerateRandomOperation<STATUS, CONTENT_TYPE>>;
  generateRandomWithSource<STATUS extends keyof GenerateRandomWithSourceResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateRandomWithSourceRequestParameters): Keq<GenerateRandomWithSourceOperation<STATUS, CONTENT_TYPE>>;
  generateRandomWithSourceAndBytes<STATUS extends keyof GenerateRandomWithSourceAndBytesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateRandomWithSourceAndBytesRequestParameters): Keq<GenerateRandomWithSourceAndBytesOperation<STATUS, CONTENT_TYPE>>;
  generateRandomWithBytes<STATUS extends keyof GenerateRandomWithBytesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GenerateRandomWithBytesRequestParameters): Keq<GenerateRandomWithBytesOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Unseal the OpenBao instance.
   *
   */
  unseal<STATUS extends keyof UnsealResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UnsealRequestParameters): Keq<UnsealOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Look up wrapping properties for the given token.
   *
   */
  readWrappingProperties<STATUS extends keyof ReadWrappingPropertiesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: ReadWrappingPropertiesRequestParameters): Keq<ReadWrappingPropertiesOperation<STATUS, CONTENT_TYPE>>;
  rewrap<STATUS extends keyof RewrapResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: RewrapRequestParameters): Keq<RewrapOperation<STATUS, CONTENT_TYPE>>;
  unwrap<STATUS extends keyof UnwrapResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: UnwrapRequestParameters): Keq<UnwrapOperation<STATUS, CONTENT_TYPE>>;
  wrap<STATUS extends keyof WrapResponseBodies, CONTENT_TYPE extends never = never>(args?: WrapRequestParameters): Keq<WrapOperation<STATUS, CONTENT_TYPE>>;
  transitBackUpKey<STATUS extends keyof TransitBackUpKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitBackUpKeyRequestParameters): Keq<TransitBackUpKeyOperation<STATUS, CONTENT_TYPE>>;
  transitByokKey<STATUS extends keyof TransitByokKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitByokKeyRequestParameters): Keq<TransitByokKeyOperation<STATUS, CONTENT_TYPE>>;
  transitByokKeyVersion<STATUS extends keyof TransitByokKeyVersionResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitByokKeyVersionRequestParameters): Keq<TransitByokKeyVersionOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Returns the size of the active cache
   *
   */
  transitReadCacheConfiguration<STATUS extends keyof TransitReadCacheConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitReadCacheConfigurationRequestParameters): Keq<TransitReadCacheConfigurationOperation<STATUS, CONTENT_TYPE>>;
  /**
   * Configures a new cache of the specified size
   *
   */
  transitConfigureCache<STATUS extends keyof TransitConfigureCacheResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitConfigureCacheRequestParameters): Keq<TransitConfigureCacheOperation<STATUS, CONTENT_TYPE>>;
  transitReadKeysConfiguration<STATUS extends keyof TransitReadKeysConfigurationResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitReadKeysConfigurationRequestParameters): Keq<TransitReadKeysConfigurationOperation<STATUS, CONTENT_TYPE>>;
  transitConfigureKeys<STATUS extends keyof TransitConfigureKeysResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitConfigureKeysRequestParameters): Keq<TransitConfigureKeysOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateDataKey<STATUS extends keyof TransitGenerateDataKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateDataKeyRequestParameters): Keq<TransitGenerateDataKeyOperation<STATUS, CONTENT_TYPE>>;
  transitDecrypt<STATUS extends keyof TransitDecryptResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitDecryptRequestParameters): Keq<TransitDecryptOperation<STATUS, CONTENT_TYPE>>;
  transitDeriveKey<STATUS extends keyof TransitDeriveKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitDeriveKeyRequestParameters): Keq<TransitDeriveKeyOperation<STATUS, CONTENT_TYPE>>;
  transitEncrypt<STATUS extends keyof TransitEncryptResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitEncryptRequestParameters): Keq<TransitEncryptOperation<STATUS, CONTENT_TYPE>>;
  transitExportKey<STATUS extends keyof TransitExportKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitExportKeyRequestParameters): Keq<TransitExportKeyOperation<STATUS, CONTENT_TYPE>>;
  transitExportKeyVersion<STATUS extends keyof TransitExportKeyVersionResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitExportKeyVersionRequestParameters): Keq<TransitExportKeyVersionOperation<STATUS, CONTENT_TYPE>>;
  transitHash<STATUS extends keyof TransitHashResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitHashRequestParameters): Keq<TransitHashOperation<STATUS, CONTENT_TYPE>>;
  transitHashWithAlgorithm<STATUS extends keyof TransitHashWithAlgorithmResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitHashWithAlgorithmRequestParameters): Keq<TransitHashWithAlgorithmOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateHmac<STATUS extends keyof TransitGenerateHmacResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateHmacRequestParameters): Keq<TransitGenerateHmacOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateHmacWithAlgorithm<STATUS extends keyof TransitGenerateHmacWithAlgorithmResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateHmacWithAlgorithmRequestParameters): Keq<TransitGenerateHmacWithAlgorithmOperation<STATUS, CONTENT_TYPE>>;
  transitListKeys<STATUS extends keyof TransitListKeysResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitListKeysRequestParameters): Keq<TransitListKeysOperation<STATUS, CONTENT_TYPE>>;
  transitReadKey<STATUS extends keyof TransitReadKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitReadKeyRequestParameters): Keq<TransitReadKeyOperation<STATUS, CONTENT_TYPE>>;
  transitCreateKey<STATUS extends keyof TransitCreateKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitCreateKeyRequestParameters): Keq<TransitCreateKeyOperation<STATUS, CONTENT_TYPE>>;
  transitDeleteKey<STATUS extends keyof TransitDeleteKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitDeleteKeyRequestParameters): Keq<TransitDeleteKeyOperation<STATUS, CONTENT_TYPE>>;
  transitConfigureKey<STATUS extends keyof TransitConfigureKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitConfigureKeyRequestParameters): Keq<TransitConfigureKeyOperation<STATUS, CONTENT_TYPE>>;
  getCsr<STATUS extends keyof GetCsrResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: GetCsrRequestParameters): Keq<GetCsrOperation<STATUS, CONTENT_TYPE>>;
  transitImportKey<STATUS extends keyof TransitImportKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitImportKeyRequestParameters): Keq<TransitImportKeyOperation<STATUS, CONTENT_TYPE>>;
  transitImportKeyVersion<STATUS extends keyof TransitImportKeyVersionResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitImportKeyVersionRequestParameters): Keq<TransitImportKeyVersionOperation<STATUS, CONTENT_TYPE>>;
  transitRotateKey<STATUS extends keyof TransitRotateKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitRotateKeyRequestParameters): Keq<TransitRotateKeyOperation<STATUS, CONTENT_TYPE>>;
  setChain<STATUS extends keyof SetChainResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: SetChainRequestParameters): Keq<SetChainOperation<STATUS, CONTENT_TYPE>>;
  transitSoftDeleteKey<STATUS extends keyof TransitSoftDeleteKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitSoftDeleteKeyRequestParameters): Keq<TransitSoftDeleteKeyOperation<STATUS, CONTENT_TYPE>>;
  transitSoftDeleteRestoreKey<STATUS extends keyof TransitSoftDeleteRestoreKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitSoftDeleteRestoreKeyRequestParameters): Keq<TransitSoftDeleteRestoreKeyOperation<STATUS, CONTENT_TYPE>>;
  transitTrimKey<STATUS extends keyof TransitTrimKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitTrimKeyRequestParameters): Keq<TransitTrimKeyOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateRandom<STATUS extends keyof TransitGenerateRandomResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateRandomRequestParameters): Keq<TransitGenerateRandomOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateRandomWithSource<STATUS extends keyof TransitGenerateRandomWithSourceResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateRandomWithSourceRequestParameters): Keq<TransitGenerateRandomWithSourceOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateRandomWithSourceAndBytes<STATUS extends keyof TransitGenerateRandomWithSourceAndBytesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateRandomWithSourceAndBytesRequestParameters): Keq<TransitGenerateRandomWithSourceAndBytesOperation<STATUS, CONTENT_TYPE>>;
  transitGenerateRandomWithBytes<STATUS extends keyof TransitGenerateRandomWithBytesResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitGenerateRandomWithBytesRequestParameters): Keq<TransitGenerateRandomWithBytesOperation<STATUS, CONTENT_TYPE>>;
  transitRestoreKey<STATUS extends keyof TransitRestoreKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitRestoreKeyRequestParameters): Keq<TransitRestoreKeyOperation<STATUS, CONTENT_TYPE>>;
  transitRestoreAndRenameKey<STATUS extends keyof TransitRestoreAndRenameKeyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitRestoreAndRenameKeyRequestParameters): Keq<TransitRestoreAndRenameKeyOperation<STATUS, CONTENT_TYPE>>;
  transitRewrap<STATUS extends keyof TransitRewrapResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitRewrapRequestParameters): Keq<TransitRewrapOperation<STATUS, CONTENT_TYPE>>;
  transitSign<STATUS extends keyof TransitSignResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitSignRequestParameters): Keq<TransitSignOperation<STATUS, CONTENT_TYPE>>;
  transitSignWithAlgorithm<STATUS extends keyof TransitSignWithAlgorithmResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitSignWithAlgorithmRequestParameters): Keq<TransitSignWithAlgorithmOperation<STATUS, CONTENT_TYPE>>;
  transitVerify<STATUS extends keyof TransitVerifyResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitVerifyRequestParameters): Keq<TransitVerifyOperation<STATUS, CONTENT_TYPE>>;
  transitVerifyWithAlgorithm<STATUS extends keyof TransitVerifyWithAlgorithmResponseBodies, CONTENT_TYPE extends 'application/json' = 'application/json'>(args?: TransitVerifyWithAlgorithmRequestParameters): Keq<TransitVerifyWithAlgorithmOperation<STATUS, CONTENT_TYPE>>;
  transitReadWrappingKey<STATUS extends keyof TransitReadWrappingKeyResponseBodies, CONTENT_TYPE extends never = never>(args?: TransitReadWrappingKeyRequestParameters): Keq<TransitReadWrappingKeyOperation<STATUS, CONTENT_TYPE>>;
}
//#endregion
//#region src/modules/blind-index/blind-index.module.d.ts
/**
 * BlindIndexModule 提供盲索引(Blind Index)能力，用于对敏感数据生成不可逆的哈希值，
 * 以便在加密存储场景下仍可进行等值查询，而无需暴露原始明文。
 *
 * 该模块为全局模块，导入一次后即可在任意位置注入 `BlindIndexService`。
 * 内部通过版本化的 Hasher Provider 实现算法调度，`generate()` 始终使用最新版本算法。
 *
 * @example
 * // 1. 在 AppModule 中导入
 * import { BlindIndexModule } from '@buka/nestjs-kit'
 *
 * @Module({
 *   imports: [BlindIndexModule],
 * })
 * export class AppModule {}
 *
 * @example
 * // 2. 在 Service 中注入使用
 * import { BlindIndexService, BlindIndex } from '@buka/nestjs-kit'
 *
 * @Injectable()
 * export class UserService {
 *   constructor(private readonly blindIndexService: BlindIndexService) {}
 *
 *   async createUser(email: string) {
 *     // 生成盲索引，可存入数据库用于后续查询
 *     const blindIndex: BlindIndex = await this.blindIndexService.generate(email)
 *     // blindIndex.value   -> 哈希值
 *     // blindIndex.version -> 哈希算法版本号
 *   }
 * }
 *
 * @example
 * // 3. 在 MikroORM Entity 中使用 BlindIndex 嵌入类型
 * import { Entity, Embedded } from '@mikro-orm/core'
 * import { BlindIndex } from '@buka/nestjs-kit'
 *
 * @Entity()
 * export class User {
 *   @Embedded(() => BlindIndex)
 *   emailIndex!: BlindIndex
 * }
 */
declare class BlindIndexModule {}
//#endregion
//#region src/modules/blind-index/entities/blind-index.embeddable.d.ts
declare class BlindIndex {
  value: string;
  version: number;
}
//#endregion
//#region src/modules/blind-index/types/blind-index-hasher.d.ts
/**
 * 盲索引算法抽象接口
 *
 * 每个版本的盲索引算法实现该接口，由 `BlindIndexService` 统一调度。
 * 通过 `version` 字段区分不同算法，支持平滑升级。
 */
interface BlindIndexHasher {
  /**
   * 算法版本号
   */
  version: number;
  /**
   * 对数据生成盲索引
   *
   * @param data - 待哈希的 JSON 数据
   * @returns 包含 value 和 version 的 {@link BlindIndex} 对象
   */
  generate(data: JsonValue): Promise<BlindIndex>;
}
//#endregion
//#region src/modules/blind-index/blind-index-v1.hasher.d.ts
/**
 * 盲索引 V1 实现
 *
 * 使用 SHA-256 对 JSON 稳定序列化后的字符串计算哈希
 */
declare class BlindIndexV1Hasher implements BlindIndexHasher {
  version: 1;
  generate(data: JsonValue): Promise<BlindIndex>;
}
//#endregion
//#region src/modules/blind-index/blind-index.service.d.ts
declare class BlindIndexService {
  private readonly hasherV1;
  private readonly logger;
  private readonly hashers;
  private readonly defaultHasher;
  constructor(hasherV1: BlindIndexV1Hasher);
  /**
   * 对数据生成盲索引
   *
   * @param data - 待哈希的 JSON 数据
   * @returns 包含 value 和 version 的 {@link BlindIndex} 对象
   */
  generate(data: JsonValue): Promise<BlindIndex>;
}
//#endregion
//#region src/modules/salted-hash/salted-hash.module.d.ts
/**
 * SaltedHashModule 提供加盐哈希能力，适用于密码存储等需要不可逆且抗彩虹表攻击的场景。
 *
 * 该模块为全局模块，导入一次后即可在任意位置注入 `SaltedHashService`。
 * 内部通过版本化的 Hasher Provider 实现算法调度，`hash()` 始终使用最新版本算法，
 * `verify()` 根据 `saltedHash.version` 自动选择对应版本算法，确保历史数据可正确验证。
 *
 * @example
 * // 1. 在 AppModule 中导入
 * import { SaltedHashModule } from '@buka/nestjs-kit'
 *
 * @Module({
 *   imports: [SaltedHashModule],
 * })
 * export class AppModule {}
 *
 * @example
 * // 2. 注册用户时生成密码哈希
 * import { SaltedHashService, SaltedHash } from '@buka/nestjs-kit'
 *
 * @Injectable()
 * export class UserService {
 *   constructor(private readonly saltedHashService: SaltedHashService) {}
 *
 *   async register(password: string) {
 *     const saltedHash: SaltedHash = await this.saltedHashService.hash(password)
 *     // saltedHash.hash    -> 哈希字符串
 *     // saltedHash.version -> 哈希算法版本号
 *     // 将 saltedHash 存入数据库
 *   }
 *
 *   async login(password: string, savedHash: SaltedHash) {
 *     const isValid = await this.saltedHashService.verify(password, savedHash)
 *     if (!isValid) throw new UnauthorizedException()
 *   }
 * }
 *
 * @example
 * // 3. 在 MikroORM Entity 中使用 SaltedHash 嵌入类型
 * import { Entity, Embedded } from '@mikro-orm/core'
 * import { SaltedHash } from '@buka/nestjs-kit'
 *
 * @Entity()
 * export class User {
 *   @Embedded(() => SaltedHash)
 *   password!: SaltedHash
 * }
 */
declare class SaltedHashModule {}
//#endregion
//#region src/modules/salted-hash/entities/salted-hash.embeddable.d.ts
/**
 * SaltedHash 嵌入实体，用于在 MikroORM Entity 中存储加盐哈希结果。
 *
 * - `hash`: 哈希字符串
 * - `version`: 哈希算法版本号，便于后续升级算法时做兼容处理
 */
declare class SaltedHash {
  hash: string & Hidden;
  version: number & Hidden;
}
//#endregion
//#region src/modules/salted-hash/types/salted-hash-hasher.d.ts
/**
 * 加盐哈希算法抽象接口
 *
 * 每个版本的哈希算法实现该接口，由 `SaltedHashService` 统一调度。
 * 通过 `version` 字段区分不同算法，支持平滑升级。
 */
interface SaltedHashHasher {
  /**
   * 算法版本号
   */
  version: number;
  /**
   * 对明文生成加盐哈希
   *
   * @param plain - 待哈希的明文字符串
   * @returns 包含 hash 和 version 的 {@link SaltedHash} 对象
   */
  hash(plain: string): Promise<SaltedHash>;
  /**
   * 验证明文是否与已有的加盐哈希匹配
   *
   * @param plain - 待验证的明文字符串
   * @param saltedHash - 之前生成的 {@link SaltedHash} 对象
   * @returns 匹配返回 `true`，否则返回 `false`
   */
  verify(plain: string, saltedHash: SaltedHash): Promise<boolean>;
}
//#endregion
//#region src/modules/salted-hash/salted-hash-v1.hasher.d.ts
/**
 * 加盐哈希 V1 实现
 *
 * 使用 bcrypt 算法，cost factor 为 10
 */
declare class SaltedHashV1Hasher implements SaltedHashHasher {
  version: 1;
  hash(plain: string): Promise<SaltedHash>;
  verify(plain: string, saltedHash: SaltedHash): Promise<boolean>;
}
//#endregion
//#region src/modules/salted-hash/salted-hash.service.d.ts
declare class SaltedHashService {
  private readonly hasherV1;
  private readonly logger;
  private readonly hashers;
  private readonly defaultHasher;
  constructor(hasherV1: SaltedHashV1Hasher);
  /**
   * 对明文数据生成加盐哈希
   *
   * @param plain - 待哈希的明文字符串（如密码）
   * @returns 包含 hash、version 的 {@link SaltedHash} 对象
   */
  hash(plain: string): Promise<SaltedHash>;
  /**
   * 验证明文是否与已有的加盐哈希匹配
   *
   * 会根据 `saltedHash.version` 自动选择对应版本的哈希算法进行验证，
   * 因此即使默认版本已升级，历史数据仍可正确验证。
   *
   * @param plain - 待验证的明文字符串
   * @param saltedHash - 之前生成的 {@link SaltedHash} 对象
   * @returns 匹配返回 `true`，否则返回 `false`
   */
  verify(plain: string, saltedHash: SaltedHash): Promise<boolean>;
}
//#endregion
//#region src/modules/exception/constants/exception-detail-schema.d.ts
declare const ExceptionDetailSchema: {
  type: string;
  properties: {
    type: {
      type: string;
    };
  };
  required: string[];
  additionalProperties: boolean;
};
//#endregion
//#region src/modules/exception/constants/error-response-schema.d.ts
declare const ErrorResponseSchema: {
  type: string;
  properties: {
    error: {
      type: string;
      properties: {
        code: {
          type: string;
        };
        message: {
          type: string;
        };
        details: {
          type: string;
          items: {
            type: string;
            properties: {
              type: {
                type: string;
              };
            };
            required: string[];
            additionalProperties: boolean;
          };
        };
      };
      required: string[];
      additionalProperties: boolean;
    };
  };
  required: string[];
  additionalProperties: boolean;
};
//#endregion
//#region src/modules/exception/error-code.registry.d.ts
interface ExceptionMeta {
  category: ErrorCategory$1;
  moduleId: number;
  sequenceId: number;
}
/**
 * 错误码注册中心
 *
 * 负责:
 * 1. 管理 systemId (全局唯一，由业务系统配置一次)
 * 2. 校验 moduleId 唯一性 (每个 moduleId 只能被一个模块使用)
 * 3. 校验错误码唯一性 (category + moduleId + sequenceId)
 */
declare class ErrorCodeRegistry {
  private static instance;
  private systemId;
  private readonly codeKeys;
  private readonly descriptions;
  private readonly moduleIds;
  private constructor();
  static getInstance(): ErrorCodeRegistry;
  /**
   * 配置系统ID
   * @param systemId 系统ID (0 - 1048575)
   */
  setSystemId(systemId: number): void;
  /**
   * 获取系统ID
   */
  getSystemId(): number;
  /**
   * 检查系统ID是否已配置
   */
  hasSystemId(): boolean;
  /**
   * 注册模块ID
   * @param moduleId 模块ID
   * @param moduleName 模块名称 (用于错误提示)
   */
  registerModule(moduleId: number, moduleName: string): void;
  /**
   * 获取模块名称
   * @param moduleId 模块ID
   */
  getModuleName(moduleId: number): string | undefined;
  /**
   * 获取所有已注册的模块
   */
  getAllRegisteredModules(): Map<number, string>;
  /**
   * 注册错误码
   * @param meta 错误码元信息
   * @param className 异常类名 (用于错误提示)
   * @param description 错误描述 (用于错误码查询接口)
   */
  register(meta: ExceptionMeta, className: string, description?: string): void;
  /**
   * 获取错误码描述
   * @param key 错误码 key (category-moduleId-sequenceId)
   */
  getDescription(key: string): string | undefined;
  /**
   * 获取所有已注册的错误码
   */
  getAllRegisteredCodes(): Map<string, string>;
  /**
   * 清空注册 (仅用于测试)
   */
  clear(): void;
}
//#endregion
//#region src/modules/exception/dto/error-code-parts.dto.d.ts
declare class ErrorCodePartsDto {
  category: ErrorCategory$1;
  system: number;
  module: number;
  sequence: number;
}
//#endregion
//#region src/modules/exception/dto/error-code-metadata.dto.d.ts
declare class ErrorCodeMetadataDto {
  moduleName: string;
  phrase: string;
  description?: string;
}
//#endregion
//#region src/modules/exception/dto/error-code-definition.dto.d.ts
declare class ErrorCodeDefinitionDto {
  code: string;
  raw: string;
  parts: ErrorCodePartsDto;
  metadata: ErrorCodeMetadataDto;
}
//#endregion
//#region src/modules/exception/dto/list-error-codes-response.dto.d.ts
declare const ListErrorCodesResponseDto_base: _$type_fest0.Class<IListResponseBody<ErrorCodeDefinitionDto, "offset" | "cursor">> & {
  fromSlice(slice: Slice<ErrorCodeDefinitionDto>): IListResponseBody<ErrorCodeDefinitionDto, "offset" | "cursor">;
};
declare class ListErrorCodesResponseDto extends ListErrorCodesResponseDto_base {}
//#endregion
//#region src/modules/exception/error-code.controller.d.ts
declare class ErrorCodeController {
  list(): ListErrorCodesResponseDto;
}
//#endregion
//#region src/modules/exception/http-exception.d.ts
interface HttpExceptionOptions extends ExceptionOptions$1 {
  /** HTTP 状态码 */
  httpStatus: HttpStatus;
}
/**
 * NestJS 业务异常基类
 *
 * 继承自 @buka/exception 的 Exception，添加了 HTTP 状态码支持
 *
 * @example
 * ```typescript
 * class UserNotFoundException extends BukaException {
 *   constructor(userId: string) {
 *     super({
 *       message: `User ${userId} not found`,
 *       category: ErrorCategory.BUSINESS,
 *       moduleId: 10,
 *       sequenceId: 1,
 *       httpStatus: HttpStatus.NOT_FOUND,
 *     })
 *   }
 * }
 * ```
 */
declare class HttpException extends Exception {
  /** HTTP 状态码 */
  readonly httpStatus: HttpStatus;
  constructor(options: HttpExceptionOptions);
}
//#endregion
//#region src/modules/exception/pending-exception.factory.d.ts
/**
 * 异常选项 - 使用固定消息
 */
interface ExceptionOptionsWithMessage {
  /** 序列号 (0-32767) */
  sequenceId: number;
  /** 默认错误消息 */
  message: string;
  /** HTTP状态码 (可选，使用默认值) */
  httpStatus?: HttpStatus;
  /** 错误描述，用于错误码查询接口展示详细信息和解决方案 */
  description?: string;
}
/**
 * 异常选项 - 使用消息工厂函数
 *
 * @example
 * ```typescript
 * static readonly NotFound = BusinessException({
 *   sequenceId: 1,
 *   messageFactory: (userId: string) => `User ${userId} not found`,
 * })
 *
 * throw new UserExceptions.NotFound('123')
 * ```
 */
interface ExceptionOptionsWithFactory<TArgs extends unknown[]> {
  /** 序列号 (0-32767) */
  sequenceId: number;
  /** 消息工厂函数，用于生成错误消息 */
  messageFactory: (...args: TArgs) => string;
  /** HTTP状态码 (可选，使用默认值) */
  httpStatus?: HttpStatus;
  /** 错误描述，用于错误码查询接口展示详细信息和解决方案 */
  description?: string;
}
type ExceptionOptions<TArgs extends unknown[] = []> = ExceptionOptionsWithMessage | ExceptionOptionsWithFactory<TArgs>;
/**
 * 基础异常构造器类型 - 使用固定消息
 */
type ExceptionConstructor = new (message?: string, details?: ExceptionDetail$1 | ExceptionDetail$1[]) => HttpException;
/**
 * 自定义参数异常构造器类型 - 使用消息工厂
 */
type ExceptionConstructorWithArgs<TArgs extends unknown[]> = new (...args: [...TArgs, details?: ExceptionDetail$1 | ExceptionDetail$1[]]) => HttpException;
/**
 * 待绑定的异常类
 *
 * 如果用户忘记添加 @ModuleExceptions 装饰器直接使用，会抛出友好的错误提示
 */
declare class PendingException extends HttpException {
  /** 标记为待绑定 */
  static readonly __pending = true;
  /** 异常类别 */
  static category: ErrorCategory$1;
  /** 序列号 */
  static sequenceId: number;
  /** 默认消息 (固定消息模式) */
  static defaultMessage?: string;
  /** 消息工厂函数 (工厂模式) */
  static messageFactory?: (...args: unknown[]) => string;
  /** HTTP状态码 */
  static defaultHttpStatus: HttpStatus;
  /** 错误描述 */
  static defaultDescription?: string;
  constructor();
}
/**
 * 系统异常
 *
 * 用于系统级错误，如数据库连接失败、内部服务错误等
 *
 * @example
 * ```typescript
 * @ModuleExceptions({ moduleId: 1 })
 * export class UserExceptions {
 *   static readonly DatabaseError = SystemException({
 *     sequenceId: 1,
 *     message: 'Database connection failed',
 *   })
 * }
 * ```
 */
declare const SystemException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 业务异常
 *
 * 用于业务逻辑错误，如资源不存在、余额不足等
 *
 * @example
 * ```typescript
 * @ModuleExceptions({ moduleId: 1 })
 * export class UserExceptions {
 *   // 固定消息模式
 *   static readonly NotFound = BusinessException({
 *     sequenceId: 1,
 *     message: 'User not found',
 *   })
 *
 *   // 工厂模式 - 自定义构造参数
 *   static readonly NotFoundById = BusinessException({
 *     sequenceId: 2,
 *     messageFactory: (userId: string) => `User ${userId} not found`,
 *   })
 * }
 *
 * // 使用默认消息
 * throw new UserExceptions.NotFound()
 *
 * // 覆盖默认消息
 * throw new UserExceptions.NotFound('Custom message')
 *
 * // 使用工厂模式
 * throw new UserExceptions.NotFoundById('123')
 * ```
 */
declare const BusinessException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 验证异常
 *
 * 用于参数校验错误
 */
declare const ValidationException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 第三方服务异常
 *
 * 用于第三方服务调用失败
 */
declare const ThirdPartyException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 认证异常
 *
 * 用于认证/授权相关错误
 */
declare const AuthException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 限流异常
 *
 * 用于请求被限流
 */
declare const RateLimitException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 降级异常
 *
 * 用于服务降级场景
 */
declare const DegradeException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 冲突异常
 *
 * 用于资源状态冲突
 */
declare const ConflictException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
/**
 * 功能不可用异常
 *
 * 用于功能未开放或权限不足
 */
declare const FeatureException: {
  <TArgs extends unknown[]>(options: ExceptionOptionsWithFactory<TArgs>): ExceptionConstructorWithArgs<TArgs>;
  (options: ExceptionOptionsWithMessage): ExceptionConstructor;
};
//#endregion
//#region src/modules/exception/decorators/exception-module.decorator.d.ts
interface ExceptionModuleOptions$1 {
  /**
   * 模块ID (0 - 1048575)
   * 每个模块唯一，用于区分不同业务模块的错误码
   * 支持十进制数字或 Crockford Base32 字符串
   */
  moduleId: number | string;
}
/**
 * 异常模块装饰器
 *
 * 用于定义一组异常类，自动绑定 moduleId 并注册到 ErrorCodeRegistry
 *
 * @example
 * ```typescript
 * import { ModuleExceptions, BusinessException, ValidationException } from '@buka/nestjs-kit'
 *
 * @ModuleExceptions({ moduleId: '1000' })
 * export class UserExceptions {
 *   static readonly NotFound = BusinessException({
 *     sequenceId: 1,
 *     message: 'User not found',
 *   })
 *   static readonly AlreadyExists = BusinessException({
 *     sequenceId: 2,
 *     message: 'User already exists',
 *   })
 *   static readonly InvalidEmail = ValidationException({
 *     sequenceId: 1,
 *     message: 'Invalid email format',
 *   })
 * }
 *
 * // 使用默认消息
 * throw new UserExceptions.NotFound()
 *
 * // 覆盖默认消息
 * throw new UserExceptions.NotFound('Custom message')
 * ```
 */
declare function ModuleExceptions(options: ExceptionModuleOptions$1): ClassDecorator;
/**
 * 获取异常模块的 moduleId
 * @param target 目标类
 */
declare function getExceptionModuleId(target: Function): number | undefined;
/**
 * 类型辅助：将 PendingExceptionConfig 转换为 ExceptionConstructor
 *
 * 用于让 TypeScript 正确推断装饰后的类型
 */
type ResolveExceptions<T> = { [K in keyof T]: T[K] extends {
  __pending: true;
} ? ExceptionConstructor : T[K] };
//#endregion
//#region src/modules/exception/exception.module-definition.d.ts
interface ExceptionModuleOptions {
  /**
   * 系统ID (0 - 1048575)
   * 全公司唯一，用于区分不同业务系统
   */
  systemId: number | string;
}
declare const ConfigurableModuleClass$2: _$_nestjs_common0.ConfigurableModuleCls<ExceptionModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
//#endregion
//#region src/modules/exception/exception.module.d.ts
/**
 * 错误码模块
 *
 * @example
 * ```typescript
 * import { Module } from '@nestjs/common';
 * import { ExceptionModule } from '@buka/nestjs-kit';
 *
 * @Module({
 *   imports: [
 *     ExceptionModule.register({
 *       systemId: '1001', // 你的系统ID，支持 Base32 字符串或十进制数字
 *     }),
 *   ],
 * })
 * export class AppModule {}
 * ```
 */
declare class ExceptionModule extends ConfigurableModuleClass$2 implements OnModuleInit {
  private readonly options;
  onModuleInit(): void;
}
//#endregion
//#region src/modules/exception/buka.exceptions.d.ts
/**
 * 内置异常定义（moduleId: 0）
 *
 * 与 ErrorCodeExceptionFilter 中 HTTP 状态码映射表一一对应。
 * 用户可以直接 `throw new BukaExceptions.BadRequest()` 来使用这些内置错误码，
 * 而不必依赖 NestJS 内置 HttpException 被 filter 隐式映射。
 */
declare class BukaExceptions {
  static readonly BadRequest: ExceptionConstructor;
  static readonly UnsupportedMediaType: ExceptionConstructor;
  static readonly Unauthorized: ExceptionConstructor;
  static readonly Forbidden: ExceptionConstructor;
  static readonly NotFound: ExceptionConstructor;
  static readonly Conflict: ExceptionConstructor;
  static readonly TooManyRequests: ExceptionConstructor;
  static readonly InternalServerError: ExceptionConstructor;
  static readonly BadGateway: ExceptionConstructor;
  static readonly GatewayTimeout: ExceptionConstructor;
  static readonly ServiceUnavailable: ExceptionConstructor;
}
//#endregion
//#region src/modules/exception/filters/exception.filter.d.ts
/**
 * 全局异常过滤器
 *
 * 统一处理所有异常，转换为标准错误码格式响应
 */
declare class ErrorCodeExceptionFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost): void;
  private handleException;
  private handleHttpException;
  private handleUnknownException;
}
//#endregion
//#region src/modules/envelope-encryption/types/envelope-encryption-module-options.d.ts
interface EnvelopeEncryptionModuleOptions {
  /**
   * @default 1
   */
  version?: 1;
  /**
   * 模块初始化时预加载的 KEK ID 列表，每个 ID 须与 OpenBao Transit key 名称对应。
   * 列表中的 KEK 会在启动时验证（快速失败）。
   * 未列出的 KEK 将在首次使用时懒加载。
   */
  keks?: string[];
  /**
   * 内存中 DEK 缓存的 TTL，单位为秒。
   * 设置为正数时，解密后的 DEK 明文将在内存中缓存指定时长，
   * 避免对同一加密 DEK 重复调用 OpenBao Transit 解密接口。
   * 设置为 0（默认）则禁用缓存。
   * @default 0
   */
  dekCacheTtl?: number;
}
//#endregion
//#region src/modules/envelope-encryption/envelope-encryption.module-definition.d.ts
declare const ConfigurableModuleClass$1: _$_nestjs_common0.ConfigurableModuleCls<EnvelopeEncryptionModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
//#endregion
//#region src/modules/envelope-encryption/envelope-encryption.module.d.ts
declare class EnvelopeEncryptionModule extends ConfigurableModuleClass$1 {
  static register(options?: EnvelopeEncryptionModuleOptions): DynamicModule;
}
//#endregion
//#region src/modules/envelope-encryption/commands/cipher-encrypt.command.d.ts
interface CipherEncryptCommand {
  /**
   * 用于加密数据密钥的 KEK ID
   */
  kekId: string;
  /**
   * 明文二进制数据
   */
  plaintext: Buffer;
  /**
   * 额外的附加认证数据（可选，会与 kekId 合并）
   */
  extraAad?: Record<string, any>;
}
//#endregion
//#region src/modules/envelope-encryption/commands/encrypt.command.d.ts
interface EncryptStringCommand extends Pick<CipherEncryptCommand, 'kekId' | 'extraAad'> {
  /**
   * 明文字符串数据
   */
  plaintext: string;
  /**
   * 字符编码
   *
   * @default 'utf8'
   */
  encoding?: BufferEncoding;
}
interface EncryptBufferCommand extends Pick<CipherEncryptCommand, 'kekId' | 'extraAad'> {
  /**
   * 明文二进制数据
   */
  plaintext: Buffer;
}
type EncryptCommand = EncryptStringCommand | EncryptBufferCommand;
//#endregion
//#region src/modules/envelope-encryption/entities/encrypted-payload.embeddable.d.ts
/**
 * 加密数据的嵌入式实体
 *
 * 包含加密后的数据和解密所需的参数：密文、IV、认证标签和算法版本
 *
 * @example
 * ```typescript
 * @Entity()
 * export class UserSecret extends DiscreteEntity {
 *   @Column.Embedded(() => KeyEnvelope, { object: false })
 *   envelope!: KeyEnvelope
 *
 *   @Column.Embedded(() => EncryptedPayload)
 *   payload!: EncryptedPayload
 * }
 * ```
 */
declare class EncryptedPayload {
  [HiddenProps]?: 'ciphertext' | 'cipherIv' | 'cipherTag';
  /**
   * 加密后的数据（二进制）
   */
  ciphertext: Buffer;
  /**
   * 初始化向量（二进制）
   */
  cipherIv: Buffer;
  /**
   * 认证标签（二进制，用于 GCM 模式验证数据完整性）
   */
  cipherTag: Buffer;
  /**
   * 加密算法版本号
   */
  cipherVersion: number & Hidden;
}
//#endregion
//#region src/modules/envelope-encryption/entities/key-envelope.embeddable.d.ts
/**
 * 密钥信封的嵌入式实体
 *
 * 包含密钥相关的元数据：kekId、KEK 版本号和加密的数据密钥（DEK）
 *
 * @example
 * ```typescript
 * @Entity()
 * export class UserSecret extends DiscreteEntity {
 *   @Column.Embedded(() => KeyEnvelope, { object: false })
 *   envelope!: KeyEnvelope
 *
 *   @Column.Embedded(() => EncryptedPayload)
 *   payload!: EncryptedPayload
 * }
 * ```
 */
declare class KeyEnvelope {
  [HiddenProps]?: 'dek';
  /**
   * 加密数据的唯一标识符，用于 AAD 绑定
   */
  kekId: string & Hidden;
  /**
   * KEK 版本号，用于密钥轮换追踪
   */
  kekVersion: number & Hidden;
  /**
   * 加密的数据密钥（由 KEK 加密，二进制格式）
   */
  dek: Buffer;
}
//#endregion
//#region src/modules/envelope-encryption/commands/cipher-decrypt.command.d.ts
interface CipherDecryptCommand {
  /**
   * 密钥信封实体
   */
  envelope: KeyEnvelope;
  /**
   * 加密数据实体
   */
  payload: EncryptedPayload;
  /**
   * 额外的附加认证数据（必须与加密时使用的相同）
   */
  extraAad?: Record<string, any>;
}
//#endregion
//#region src/modules/envelope-encryption/commands/decrypt.command.d.ts
interface DecryptCommand extends CipherDecryptCommand {}
//#endregion
//#region src/modules/envelope-encryption/commands/reencrypt.command.d.ts
interface ReencryptCommand extends DecryptCommand {
  /**
   * 用于加密数据密钥的新 KEK ID
   */
  keyId: string;
}
//#endregion
//#region src/modules/envelope-encryption/types/envelope-encryption-cipher.d.ts
/**
 * 信封加密服务抽象类
 *
 * 信封加密（Envelope Encryption）是一种两层加密策略：
 * 1. 使用数据加密密钥（DEK）加密实际数据
 * 2. 使用密钥加密密钥（KEK）加密 DEK
 *
 * KEK 由 OpenBao Transit 引擎管理，永远不会离开 OpenBao
 *
 * AAD 绑定：每个加密数据都会生成唯一的 kekId，kekId 会被写入 AAD，
 * 确保密文与 kekId 绑定，防止密文被替换攻击
 */
interface EnvelopeEncryptionCipher {
  /**
   * 算法版本号
   */
  version: number;
  /**
   * 算法名称
   */
  algorithm: string;
  /**
   * 使用信封加密方式加密数据
   *
   * @returns [KeyEnvelope, EncryptedPayload] 密钥信封和加密数据实体
   */
  encrypt(cmd: CipherEncryptCommand): Promise<[KeyEnvelope, EncryptedPayload]>;
  /**
   * 解密信封加密的数据
   *
   * @returns 解密后的明文
   */
  decrypt(cmd: CipherDecryptCommand): Promise<Buffer>;
}
//#endregion
//#region src/modules/envelope-encryption/kms.provider.d.ts
interface GeneratedDek {
  dek: Buffer;
  encryptedDek: Buffer;
  kekVersion: number;
}
declare class KmsProvider implements OnApplicationBootstrap, OnModuleDestroy {
  private readonly openbao;
  private readonly options;
  private readonly logger;
  private kekMetadataMap;
  private loadingPromises;
  private dekCache;
  private dekDecryptingPromises;
  private dekCacheCleanupTimer;
  constructor(openbao: OpenBaoHttpClient, options: EnvelopeEncryptionModuleOptions);
  onApplicationBootstrap(): Promise<void>;
  onModuleDestroy(): void;
  private getOrLoadKekMetadata;
  generateDek(kekId: string, _type: 'aes128-gcm96' | 'aes256-gcm96' | 'chacha20-poly1305'): Promise<GeneratedDek>;
  decryptDek(kekId: string, kekVersion: number, encryptedDek: Buffer): Promise<Buffer>;
  private getOrDecryptDek;
  private evictExpiredDekEntries;
}
//#endregion
//#region src/modules/envelope-encryption/envelope-encryption-v1.cipher.d.ts
/**
 * 信封加密服务 V1 实现
 *
 * 使用 AES-256-GCM 算法，KEK 由 OpenBao Transit 引擎管理
 */
declare class EnvelopeEncryptionV1Cipher implements EnvelopeEncryptionCipher {
  private readonly kmsProvider;
  private readonly logger;
  version: 1;
  algorithm: "aes-256-gcm";
  constructor(kmsProvider: KmsProvider);
  /**
   * 构建 AAD（附加认证数据）
   * 将 kekId 编码到 AAD 中，确保密文与 kekId 绑定
   */
  private buildAad;
  encrypt(cmd: EncryptCommand): Promise<[KeyEnvelope, EncryptedPayload]>;
  decrypt(cmd: DecryptCommand): Promise<Buffer>;
}
//#endregion
//#region src/modules/envelope-encryption/types/cipher-metadata.d.ts
interface CipherMetadata {
  version: number;
  algorithm: string;
}
//#endregion
//#region src/modules/envelope-encryption/envelope-encryption.service.d.ts
/**
 * 信封加密服务，基于信封加密模式（Envelope Encryption）提供数据加密、解密和重新加密能力。
 *
 * 使用 KEK（Key Encryption Key）保护 DEK（Data Encryption Key），支持多版本加密算法。
 *
 * @example
 * ```typescript
 * // 加密
 * const [envelope, payload] = await envelopeEncryptionService.encrypt({
 *   kekId: 'kek-001',
 *   plaintext: '敏感数据',
 * })
 *
 * // 解密
 * const plaintext = await envelopeEncryptionService.decryptToString({
 *   envelope,
 *   payload,
 * })
 * ```
 */
declare class EnvelopeEncryptionService {
  private readonly options;
  private readonly cipherV1;
  private readonly logger;
  private readonly ciphers;
  private readonly defaultCipher;
  constructor(options: EnvelopeEncryptionModuleOptions, cipherV1: EnvelopeEncryptionV1Cipher);
  private isEncryptStringCommand;
  /**
   * 使用信封加密模式加密数据，支持字符串和 Buffer 输入。
   *
   * @param cmd - 加密命令，包含 KEK ID 和明文数据
   * @returns 密钥信封和加密载荷的元组
   */
  encrypt(cmd: EncryptStringCommand): Promise<[KeyEnvelope, EncryptedPayload]>;
  encrypt(cmd: EncryptBufferCommand): Promise<[KeyEnvelope, EncryptedPayload]>;
  /**
   * 解密数据，自动匹配加密时使用的算法版本。
   *
   * @param cmd - 解密命令，包含密钥信封和加密载荷
   * @returns 解密后的 Buffer
   */
  decrypt(cmd: DecryptCommand): Promise<Buffer>;
  /**
   * 重新加密数据（使用最新版本的 KEK 和算法）
   *
   * @returns 使用新 KEK 加密的结果
   */
  reencrypt(cmd: ReencryptCommand): Promise<[KeyEnvelope, EncryptedPayload]>;
  /**
   * 解密为字符串
   *
   * @returns 解密后的字符串
   */
  decryptToString(cmd: DecryptCommand): Promise<string>;
  /**
   * 列出所有支持的加密算法的元数据
   */
  listCiphers(): CipherMetadata[];
}
//#endregion
//#region src/modules/logger/types/logger-module-options.d.ts
/**
 * LoggerModule 配置
 *
 * 与 LoggerConfig 基类字段一一对应
 */
interface LoggerModuleOptions {
  /** 服务名称，Grafana/Loki 中按服务过滤日志 */
  serviceName?: string;
  /** 运行环境，默认取 NODE_ENV */
  environment?: string;
  /** 服务版本号，生产环境由 CI/CD 注入 */
  version?: string;
  /** 日志级别，默认 info */
  level?: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
  /** 开发模式——启用 pino-pretty 彩色输出 */
  pretty?: boolean;
  /** pino-http autoLogging 配置，用于跳过指定路由的成功日志（错误日志不受影响） */
  autoLogging?: {
    ignore: (req: IncomingMessage) => boolean;
  };
}
//#endregion
//#region src/modules/logger/logger.module.d.ts
/**
 * 统一日志模块
 *
 * 基于 nestjs-pino，预配置 Grafana/Loki 友好的 JSON 日志格式。
 *
 * @example
 *   // 直接使用
 *   LoggerModule.register({ serviceName: 'my-service' })
 *
 *   // 配合 @buka/nestjs-config
 *   ConfigModule.inject(PinoConfig, LoggerModule, (config) => ({...config}))
 */
declare class LoggerModule {
  static register(options?: LoggerModuleOptions): DynamicModule;
  static registerAsync(options: {
    imports?: any[];
    inject?: any[];
    useFactory: (...args: any[]) => LoggerModuleOptions | Promise<LoggerModuleOptions>;
  }): DynamicModule;
  /**
   * 将 LoggerModuleOptions 转换为 nestjs-pino 的 Params
   */
  private static buildParams;
}
//#endregion
//#region src/modules/logger/decorators/inject-logger.decorator.d.ts
/**
 * 注入 Logger，自动以类名为日志上下文
 *
 * 用法：
 *   @InjectLogger()
 *   private readonly logger: Logger
 *
 * 等价于：
 *   @InjectPinoLogger(MyService.name)
 *   private readonly logger: Logger
 */
declare function InjectLogger(context?: string): ParameterDecorator;
//#endregion
//#region src/modules/logger/logger.config.d.ts
/**
 * 日志配置基类
 *
 * 项目中的日志配置应继承此类并通过 @Configuration('xxx') 绑定环境变量前缀
 */
declare class LoggerConfig {
  pretty: boolean;
  level: 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace';
  serviceName: string;
  environment: string;
  version: string;
}
//#endregion
//#region src/modules/object-storage/types/options.d.ts
interface ObjectStorageOptions {
  prefix?: boolean;
}
//#endregion
//#region src/modules/object-storage/types/object-storage-module-options.d.ts
interface ObjectStorageModuleOptions {
  /**
   * S3 兼容服务端点
   */
  endpoint: string;
  /**
   * 存储桶名称
   */
  bucket: string;
  /**
   * 区域
   */
  region: string;
  /**
   * Access Key ID
   */
  accessKeyId: string;
  /**
   * Secret Access Key
   */
  secretAccessKey: string;
  /**
   * 是否强制使用路径风格
   * @default false
   */
  forcePathStyle?: boolean;
  /**
   * 对象键前缀
   * @default ''
   */
  prefix?: string;
}
//#endregion
//#region src/modules/object-storage/object-storage.config.d.ts
declare class ObjectStorageModuleConfig implements ObjectStorageModuleOptions {
  endpoint: string;
  bucket: string;
  region: string;
  accessKeyId: string;
  secretAccessKey: string;
  forcePathStyle: boolean;
  prefix: string;
}
//#endregion
//#region src/modules/object-storage/object-storage.module-definition.d.ts
declare const ConfigurableModuleClass: _$_nestjs_common0.ConfigurableModuleCls<ObjectStorageModuleOptions, "register", "create", {}>, MODULE_OPTIONS_TOKEN: string | symbol;
//#endregion
//#region src/modules/object-storage/object-storage.module.d.ts
declare class ObjectStorageModule extends ConfigurableModuleClass {}
//#endregion
//#region src/modules/object-storage/object-storage.service.d.ts
/**
 * 对象存储服务，基于 AWS S3 兼容协议提供文件的上传、下载、删除等操作。
 *
 * 支持配置路径前缀（`prefix`）以实现多租户或环境隔离。
 *
 * @example
 * ```typescript
 * // 上传文件
 * const key = await objectStorageService.upload('avatars/user-001.png', fileBuffer)
 *
 * // 获取签名 URL
 * const url = await objectStorageService.getSignedUrl('avatars/user-001.png', 3600)
 * ```
 */
declare class ObjectStorageService implements OnModuleInit {
  private readonly config;
  private readonly logger;
  constructor(config: ObjectStorageModuleOptions);
  private client;
  onModuleInit(): Promise<void>;
  private trimSlashes;
  /**
   * 为路径添加配置的前缀。
   */
  prefix(path: string): string;
  private buildPath;
  /**
   * 获取文件内容，返回可读流。
   *
   * @param path - 文件路径
   * @param options - 可选配置，如是否自动添加前缀
   */
  get(path: string, options?: ObjectStorageOptions): Promise<Readable>;
  /**
   * 上传文件内容到指定路径。
   *
   * @param path - 目标文件路径
   * @param contents - 文件内容，支持字符串、Buffer 或可读流
   * @param options - 可选配置
   * @returns 实际存储的 key
   */
  upload(path: string, contents: string | Readable | Buffer, options?: ObjectStorageOptions): Promise<string>;
  /**
   * 获取文件的元数据（metadata）。
   */
  getMetadata(path: string, options?: ObjectStorageOptions): Promise<Record<string, string>>;
  /**
   * 检查文件是否存在。
   */
  exists(path: string, options?: ObjectStorageOptions): Promise<boolean>;
  /**
   * 删除指定路径的文件。
   */
  remove(path: string, options?: ObjectStorageOptions): Promise<void>;
  /**
   * 获取文件的预签名 URL，用于临时授权访问。
   *
   * @param path - 文件路径
   * @param expiresInSecond - URL 有效期（秒）
   * @param options - 可选配置
   */
  getSignedUrl(path: string, expiresInSecond: number, options?: ObjectStorageOptions): Promise<string>;
}
//#endregion
//#region src/modules/keq/buka-request.exception.d.ts
interface BukaRequestExceptionOptions {
  code: string;
  details?: ExceptionDetail$1[];
  response?: Response;
  fatal?: boolean;
}
declare class BukaRequestException extends RequestException {
  readonly code: string;
  readonly errorCode: ErrorCode$1;
  readonly details: ExceptionDetail$1[];
  constructor(statusCode: number, message: string, options: BukaRequestExceptionOptions);
}
//#endregion
//#region src/modules/keq/throw-on-response-error.middleware.d.ts
interface ThrowOnResponseErrorOptions {
  errorDispatchers?: Record<string, new (statusCode: number, message: string, options: BukaRequestExceptionOptions) => BukaRequestException>;
  /**
   * 开启后，错误体解析失败时输出 debug 日志
   * @default false
   */
  debug?: boolean;
}
declare function throwOnResponseError(options?: ThrowOnResponseErrorOptions): KeqMiddleware;
//#endregion
//#region src/utils/stable-stringify.d.ts
/**
 * 稳定的 JSON 序列化，确保键按字母顺序排列，忽略 null 和 undefined
 */
declare function stableStringify(value: unknown): string;
//#endregion
export { AssociationMetadata, AuthException, BUKA_MODULE_OPTIONS_TOKEN, Base32, BlindIndex, BlindIndexHasher, BlindIndexModule, BlindIndexService, BlindIndexV1Hasher, BukaConfigurableModuleClass, BukaExceptions, BukaModule, BukaModuleOptions, BukaPageQueryValidationPipe, BukaRequestException, type BukaRequestExceptionOptions, BukaValidationPipe, BusinessException, Cardinality, type CipherMetadata, CollectionAssociationMetadata, Column, Composite, CompositePropertyMetadata, ConfigurableModuleClass, ConflictException, CursorPagination, DatabaseConfig, type DecryptCommand, DegradeException, Dictionary, DictionaryPropertyMetadata, DiscreteEntity, type EncryptCommand, EncryptedPayload, EntityDto, EntityDtoShape, EntityRef, Enum, EnumPropertyMetadata, EnvelopeEncryptionModule, type EnvelopeEncryptionModuleOptions, EnvelopeEncryptionService, ErrorCategory, ErrorCode, ErrorCodeController, ErrorCodeExceptionFilter, ErrorCodeDefinitionDto as ErrorCodeItemDto, ErrorCodeMetadataDto, type ErrorCodeOptions, ErrorCodePartsDto, ErrorCodeRegistry, ErrorResponseSchema, type ExceptionConstructor, type ExceptionConstructorWithArgs, type ExceptionDetail, ExceptionDetailSchema, ExceptionModule, type ExceptionModuleOptions as ExceptionNestModuleOptions, type ExceptionOptions, type ExceptionOptionsWithFactory, type ExceptionOptionsWithMessage, ExcludeDefinedOpt, ExcludeHidden, ExcludeOpt, ExcludeRef, ExcludeScalarClass, FeatureException, FilterQuery, FilterQueryOperator, FilterQueryOperators, FilterQueryOperatorsMetadataKey, FilterQueryTransformPipe, HAS_ANY_KEY, HasAnyKey, HttpException, type HttpExceptionOptions, ICollectionOperator, IEntityPrimaryKey, IFilter, IFilterQuery, IListResponseBody, IListResponseBodyMeta, INestedOperator, INextCursorPageParameters, IObjectOperator, IOffsetPageParameters, IOrderQuery, IPageQuery, IPreviousCursorPageParameters, IPropertyOperator, IResponseBody, IS_CROCKFORD_BASE32, IS_DOMAIN_URN, IS_ENUM_COLUMN, IS_SCALAR_DICTIONARY, IS_URN, IScalarOperator, InjectLogger, IntersectionType, IsBrowserRequest, IsCrockfordBase32, IsDomainUrn, IsEnumColumn, IsHidden, IsOpt, IsScalar, IsScalarDictionary, IsUrn, KeyEnvelope, LinearEntity, List, ListErrorCodesResponseDto, ListPropertyMetadata, ListResponseBodyType, Logger, LoggerConfig, LoggerErrorInterceptor, LoggerModule, type LoggerModuleOptions, MATCH_JSON_SCHEMA, MODULE_OPTIONS_TOKEN, MatchJsonSchema, MatchesUrn, Model, ModelMetadata, ModelOptions, ModelRegister, ModelSchemaOptions, ModuleExceptions, type ExceptionModuleOptions$1 as ModuleExceptionsOptions, NextCursorPageSchema, ObjectStorageModule, ObjectStorageModuleConfig, ObjectStorageModuleOptions, ObjectStorageOptions, ObjectStorageService, OffsetPageSchema, OffsetPagination, OmitType, OpenBaoAppRoleAuth, OpenBaoAppRoleAuthConfig, OpenBaoAuthMethod, OpenBaoAuthResponse, OpenBaoHttpClient, OpenBaoKubernetesAuth, OpenBaoKubernetesAuthConfig, OpenBaoModule, OpenBaoModuleConfig, OpenBaoModuleOptions, OpenBaoTokenAuth, OpenBaoTokenAuthConfig, OpenBaoTokenLookupSelfResponse, OpenBaoTokenManager, OpenBaoUserpassAuth, OpenBaoUserpassAuthConfig, OptionalPageQuery, OrderQueryType, PageQuery, ParseUUIDv7Pipe, PartialType, PendingException, PickType, PreviousCursorPageSchema, PrimaryKeyType, PrimaryKeyTypeClassMetadataPropertyKey, Property, PropertyKind, PropertyMetadata, RateLimitException, type ReencryptCommand, RefAssociationMetadata, type ResolveExceptions, ResponseBodyType, SaltedHash, SaltedHashHasher, SaltedHashModule, SaltedHashService, SaltedHashV1Hasher, ScalarClass, ScalarPropertyMetadata, type SchemaObject, Slice, SwaggerPatcher, SystemException, ThirdPartyException, type ThrowOnResponseErrorOptions, TimestampedEntity, type UnifyExceptionResponsesOptions, Urn, VALIDATE_NESTED_DICTIONARY, ValidateNestedDictionary, ValidationException, getExceptionModuleId, getFilterQueryOperators, isScalarClass, serializeModel, setOpenBaoToken, stableStringify, throwOnResponseError };
//# sourceMappingURL=index.d.mts.map