@homeflare/distilled-openbao 0.2.0

package/src/services/generate.ts

@@ -0,0 +1,409 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-openbao, generated — see fetch-specs.ts). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  OpenBaoProtocol,
+  type OpenBaoOpError,
+  type OpenBaoOpContext,
+} from "../protocol.ts";
+import * as Retry from "../retry.ts";
+
+export type { OpenBaoOpError, OpenBaoOpContext };
+
+export 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;
+}
+export const GenerateHashRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    algorithm: S.optional(S.String),
+    format: S.optional(S.String),
+    input: S.optional(S.String),
+    urlalgorithm: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/sys/tools/hash", code: 200 })),
+).annotate({
+  identifier: "GenerateHashRequest",
+}) as any as S.Schema<GenerateHashRequest>;
+
+export interface GenerateHashResponse {
+  sum?: string;
+}
+export const GenerateHashResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sum: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GenerateHashResponse",
+}) as any as S.Schema<GenerateHashResponse>;
+
+export interface GenerateHashWithAlgorithmRequest {
+  /** Algorithm to use (POST URL parameter) */
+  urlalgorithm: string;
+  /** 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;
+}
+export const GenerateHashWithAlgorithmRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    urlalgorithm: S.String.pipe(T.Label()),
+    algorithm: S.optional(S.String),
+    format: S.optional(S.String),
+    input: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sys/tools/hash/{urlalgorithm}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GenerateHashWithAlgorithmRequest",
+}) as any as S.Schema<GenerateHashWithAlgorithmRequest>;
+
+export interface GenerateHashWithAlgorithmResponse {
+  sum?: string;
+}
+export const GenerateHashWithAlgorithmResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    sum: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GenerateHashWithAlgorithmResponse",
+}) as any as S.Schema<GenerateHashWithAlgorithmResponse>;
+
+export 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;
+}
+export const GenerateRandomRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    bytes: S.optional(S.Number),
+    format: S.optional(S.String),
+    source: S.optional(S.String),
+    urlbytes: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/sys/tools/random", code: 200 })),
+).annotate({
+  identifier: "GenerateRandomRequest",
+}) as any as S.Schema<GenerateRandomRequest>;
+
+export interface GenerateRandomResponse {
+  random_bytes?: string;
+}
+export const GenerateRandomResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    random_bytes: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GenerateRandomResponse",
+}) as any as S.Schema<GenerateRandomResponse>;
+
+export interface GenerateRandomWithBytesRequest {
+  /** The number of bytes to generate (POST URL parameter) */
+  urlbytes: string;
+  /** 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;
+}
+export const GenerateRandomWithBytesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    urlbytes: S.String.pipe(T.Label()),
+    bytes: S.optional(S.Number),
+    format: S.optional(S.String),
+    source: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/tools/random/{urlbytes}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GenerateRandomWithBytesRequest",
+}) as any as S.Schema<GenerateRandomWithBytesRequest>;
+
+export interface GenerateRandomWithBytesResponse {
+  random_bytes?: string;
+}
+export const GenerateRandomWithBytesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    random_bytes: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GenerateRandomWithBytesResponse",
+}) as any as S.Schema<GenerateRandomWithBytesResponse>;
+
+export interface GenerateRandomWithSourceRequest {
+  /** Which system to source random data from, ether "platform", "seal", or "all". */
+  source: string;
+  /** 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;
+}
+export const GenerateRandomWithSourceRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    source: S.String.pipe(T.Label()),
+    bytes: S.optional(S.Number),
+    format: S.optional(S.String),
+    urlbytes: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/sys/tools/random/{source}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GenerateRandomWithSourceRequest",
+}) as any as S.Schema<GenerateRandomWithSourceRequest>;
+
+export interface GenerateRandomWithSourceResponse {
+  random_bytes?: string;
+}
+export const GenerateRandomWithSourceResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    random_bytes: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "GenerateRandomWithSourceResponse",
+}) as any as S.Schema<GenerateRandomWithSourceResponse>;
+
+export interface GenerateRandomWithSourceAndBytesRequest {
+  /** 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;
+  /** 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;
+}
+export const GenerateRandomWithSourceAndBytesRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      source: S.String.pipe(T.Label()),
+      urlbytes: S.String.pipe(T.Label()),
+      bytes: S.optional(S.Number),
+      format: S.optional(S.String),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/tools/random/{source}/{urlbytes}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "GenerateRandomWithSourceAndBytesRequest",
+}) as any as S.Schema<GenerateRandomWithSourceAndBytesRequest>;
+
+export interface GenerateRandomWithSourceAndBytesResponse {
+  random_bytes?: string;
+}
+export const GenerateRandomWithSourceAndBytesResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      random_bytes: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "GenerateRandomWithSourceAndBytesResponse",
+}) as any as S.Schema<GenerateRandomWithSourceAndBytesResponse>;
+
+export interface GenerateRootTokenRequest {}
+export const GenerateRootTokenRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/sys/generate-root-token/attempt",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GenerateRootTokenRequest",
+}) as any as S.Schema<GenerateRootTokenRequest>;
+
+export interface GenerateRootTokenResponse {
+  complete?: boolean;
+  nonce?: string;
+  otp?: string;
+  otp_length?: number;
+  pgp_fingerprint?: string;
+  progress?: number;
+  required?: number;
+  started?: boolean;
+}
+export const GenerateRootTokenResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    complete: S.optional(S.Boolean),
+    nonce: S.optional(S.String),
+    otp: S.optional(S.String),
+    otp_length: S.optional(S.Number),
+    pgp_fingerprint: S.optional(S.String),
+    progress: S.optional(S.Number),
+    required: S.optional(S.Number),
+    started: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "GenerateRootTokenResponse",
+}) as any as S.Schema<GenerateRootTokenResponse>;
+
+export interface GenerateRootToken3Request {}
+export const GenerateRootToken3Request = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/sys/generate-root-token/attempt",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GenerateRootToken3Request",
+}) as any as S.Schema<GenerateRootToken3Request>;
+
+export interface GenerateRootToken3Response {}
+export const GenerateRootToken3Response = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "GenerateRootToken3Response",
+}) as any as S.Schema<GenerateRootToken3Response>;
+
+export type GenerateHashError = OpenBaoOpError;
+export const generateHash: API.OperationMethod<
+  GenerateHashRequest,
+  GenerateHashResponse,
+  GenerateHashError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateHashRequest,
+  output: GenerateHashResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateHashWithAlgorithmError = OpenBaoOpError;
+export const generateHashWithAlgorithm: API.OperationMethod<
+  GenerateHashWithAlgorithmRequest,
+  GenerateHashWithAlgorithmResponse,
+  GenerateHashWithAlgorithmError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateHashWithAlgorithmRequest,
+  output: GenerateHashWithAlgorithmResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRandomError = OpenBaoOpError;
+export const generateRandom: API.OperationMethod<
+  GenerateRandomRequest,
+  GenerateRandomResponse,
+  GenerateRandomError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRandomRequest,
+  output: GenerateRandomResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRandomWithBytesError = OpenBaoOpError;
+export const generateRandomWithBytes: API.OperationMethod<
+  GenerateRandomWithBytesRequest,
+  GenerateRandomWithBytesResponse,
+  GenerateRandomWithBytesError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRandomWithBytesRequest,
+  output: GenerateRandomWithBytesResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRandomWithSourceError = OpenBaoOpError;
+export const generateRandomWithSource: API.OperationMethod<
+  GenerateRandomWithSourceRequest,
+  GenerateRandomWithSourceResponse,
+  GenerateRandomWithSourceError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRandomWithSourceRequest,
+  output: GenerateRandomWithSourceResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRandomWithSourceAndBytesError = OpenBaoOpError;
+export const generateRandomWithSourceAndBytes: API.OperationMethod<
+  GenerateRandomWithSourceAndBytesRequest,
+  GenerateRandomWithSourceAndBytesResponse,
+  GenerateRandomWithSourceAndBytesError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRandomWithSourceAndBytesRequest,
+  output: GenerateRandomWithSourceAndBytesResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRootTokenError = OpenBaoOpError;
+/** Read the status of root token generation. */
+export const generateRootToken: API.OperationMethod<
+  GenerateRootTokenRequest,
+  GenerateRootTokenResponse,
+  GenerateRootTokenError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRootTokenRequest,
+  output: GenerateRootTokenResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRootToken2Error = OpenBaoOpError;
+/** Initialize root token generation. Only a single root generation attempt can take place at a time. One (and only one) of otp or pgp_key are required. */
+export const generateRootToken2: API.OperationMethod<
+  GenerateRootTokenRequest,
+  GenerateRootTokenResponse,
+  GenerateRootToken2Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRootTokenRequest,
+  output: GenerateRootTokenResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GenerateRootToken3Error = OpenBaoOpError;
+/** Cancel root token generation. */
+export const generateRootToken3: API.OperationMethod<
+  GenerateRootToken3Request,
+  GenerateRootToken3Response,
+  GenerateRootToken3Error,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GenerateRootToken3Request,
+  output: GenerateRootToken3Response,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));