@homeflare/distilled-openbao 0.2.0

package/src/services/version.ts

@@ -0,0 +1,60 @@
+// 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 type VersionHistoryRequestList = "true";
+export const VersionHistoryRequestList = S.String;
+
+export interface VersionHistoryRequest {
+  /** Must be set to `true` */
+  list: VersionHistoryRequestList | (string & {});
+}
+export const VersionHistoryRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: VersionHistoryRequestList.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/sys/version-history", code: 200 })),
+).annotate({
+  identifier: "VersionHistoryRequest",
+}) as any as S.Schema<VersionHistoryRequest>;
+
+export type VersionHistoryResponseKeysList = Array<string>;
+export const VersionHistoryResponseKeysList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<VersionHistoryResponseKeysList>;
+
+export interface VersionHistoryResponse {
+  key_info?: unknown;
+  keys?: VersionHistoryResponseKeysList;
+}
+export const VersionHistoryResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key_info: S.optional(S.Unknown),
+    keys: S.optional(VersionHistoryResponseKeysList),
+  }),
+).annotate({
+  identifier: "VersionHistoryResponse",
+}) as any as S.Schema<VersionHistoryResponse>;
+
+export type VersionHistoryError = OpenBaoOpError;
+/** Returns map of historical version change entries */
+export const versionHistory: API.OperationMethod<
+  VersionHistoryRequest,
+  VersionHistoryResponse,
+  VersionHistoryError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: VersionHistoryRequest,
+  output: VersionHistoryResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));

package/src/services/workflows.ts

@@ -0,0 +1,327 @@
+// 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 DeleteWorkflowsManagePathRequest {
+  /** Path of the workflow. */
+  path: string;
+}
+export const DeleteWorkflowsManagePathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/sys/workflows/manage/{path}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteWorkflowsManagePathRequest",
+}) as any as S.Schema<DeleteWorkflowsManagePathRequest>;
+
+export interface DeleteWorkflowsManagePathResponse {}
+export const DeleteWorkflowsManagePathResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteWorkflowsManagePathResponse",
+}) as any as S.Schema<DeleteWorkflowsManagePathResponse>;
+
+export interface ReadWorkflowsManagePathRequest {
+  /** Path of the workflow. */
+  path: string;
+  /** Return a list if `true` */
+  list?: string;
+  /** Return a recursive list if `true` */
+  scan?: string;
+}
+export const ReadWorkflowsManagePathRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    path: S.String.pipe(T.Label()),
+    list: S.optional(S.String.pipe(T.Query())),
+    scan: S.optional(S.String.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/sys/workflows/manage/{path}", code: 200 }),
+  ),
+).annotate({
+  identifier: "ReadWorkflowsManagePathRequest",
+}) as any as S.Schema<ReadWorkflowsManagePathRequest>;
+
+export interface WorkflowsReadWorkflowsManagePathResponse {
+  /** Whether this workflow can be accessed unauthenticated. */
+  allow_unauthenticated?: boolean;
+  /** Whether check and set support is required. */
+  cas_required?: boolean;
+  /** Workflow description. */
+  description?: string;
+  /** Version of the workflow. */
+  version?: number;
+  /** Workflow definition in HCL or JSON. */
+  workflow?: string;
+}
+export const WorkflowsReadWorkflowsManagePathResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      allow_unauthenticated: S.optional(S.Boolean),
+      cas_required: S.optional(S.Boolean),
+      description: S.optional(S.String),
+      version: S.optional(S.Number),
+      workflow: S.optional(S.String),
+    }),
+).annotate({
+  identifier: "WorkflowsReadWorkflowsManagePathResponse",
+}) as any as S.Schema<WorkflowsReadWorkflowsManagePathResponse>;
+
+export interface WorkflowsExecuteWriteWorkflowsExecutePathRequest {
+  /** Path of the workflow. */
+  path: string;
+}
+export const WorkflowsExecuteWriteWorkflowsExecutePathRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/workflows/execute/{path}",
+        code: 200,
+      }),
+    ),
+  ).annotate({
+    identifier: "WorkflowsExecuteWriteWorkflowsExecutePathRequest",
+  }) as any as S.Schema<WorkflowsExecuteWriteWorkflowsExecutePathRequest>;
+
+export interface WorkflowsExecuteWriteWorkflowsExecutePathResponse {}
+export const WorkflowsExecuteWriteWorkflowsExecutePathResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "WorkflowsExecuteWriteWorkflowsExecutePathResponse",
+  }) as any as S.Schema<WorkflowsExecuteWriteWorkflowsExecutePathResponse>;
+
+export type WorkflowsScanWorkflowsManageRequestList = "true";
+export const WorkflowsScanWorkflowsManageRequestList = S.String;
+
+export type WorkflowsScanWorkflowsManageRequestScan = "true";
+export const WorkflowsScanWorkflowsManageRequestScan = S.String;
+
+export interface WorkflowsScanWorkflowsManageRequest {
+  /** Must be set to `true` or else `scan` must be set to `true` */
+  list: WorkflowsScanWorkflowsManageRequestList | (string & {});
+  /** Must be set to `true` or else `list` must be set to `true` */
+  scan: WorkflowsScanWorkflowsManageRequestScan | (string & {});
+}
+export const WorkflowsScanWorkflowsManageRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: WorkflowsScanWorkflowsManageRequestList.pipe(T.Query()),
+    scan: WorkflowsScanWorkflowsManageRequestScan.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/sys/workflows/manage", code: 200 })),
+).annotate({
+  identifier: "WorkflowsScanWorkflowsManageRequest",
+}) as any as S.Schema<WorkflowsScanWorkflowsManageRequest>;
+
+/** List of workflow paths. */
+export type WorkflowsScanWorkflowsManageResponseKeysList = Array<string>;
+export const WorkflowsScanWorkflowsManageResponseKeysList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<WorkflowsScanWorkflowsManageResponseKeysList>;
+
+export interface WorkflowsScanWorkflowsManageResponse {
+  /** Map of workflow details by path. */
+  key_info?: unknown;
+  /** List of workflow paths. */
+  keys?: WorkflowsScanWorkflowsManageResponseKeysList;
+}
+export const WorkflowsScanWorkflowsManageResponse = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      key_info: S.optional(S.Unknown),
+      keys: S.optional(WorkflowsScanWorkflowsManageResponseKeysList),
+    }),
+).annotate({
+  identifier: "WorkflowsScanWorkflowsManageResponse",
+}) as any as S.Schema<WorkflowsScanWorkflowsManageResponse>;
+
+export interface WorkflowsTraceWriteWorkflowsTracePathRequest {
+  /** Path of the workflow. */
+  path: string;
+}
+export const WorkflowsTraceWriteWorkflowsTracePathRequest =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+    }).pipe(
+      T.Http({ method: "POST", uri: "/sys/workflows/trace/{path}", code: 200 }),
+    ),
+  ).annotate({
+    identifier: "WorkflowsTraceWriteWorkflowsTracePathRequest",
+  }) as any as S.Schema<WorkflowsTraceWriteWorkflowsTracePathRequest>;
+
+export interface WorkflowsTraceWriteWorkflowsTracePathResponse {}
+export const WorkflowsTraceWriteWorkflowsTracePathResponse =
+  /*@__PURE__*/ S.suspend(() => S.Struct({})).annotate({
+    identifier: "WorkflowsTraceWriteWorkflowsTracePathResponse",
+  }) as any as S.Schema<WorkflowsTraceWriteWorkflowsTracePathResponse>;
+
+export interface WorkflowsWriteWorkflowsManagePathRequest {
+  /** Path of the workflow. */
+  path: string;
+  /** Optional entry to begin listing after; not required to exist. */
+  after?: string;
+  /** Whether this workflow can be executed unauthenticated. Use with care. */
+  allow_unauthenticated?: boolean;
+  /** Check and set version of the workflow. */
+  cas?: number;
+  /** Whether to require check and set for modifying this workflow. */
+  cas_required?: boolean;
+  /** Workflow description. */
+  description?: string;
+  /** Optional number of entries to return; defaults to all entries. */
+  limit?: number;
+  /** Workflow definition in either HCL or JSON format. */
+  workflow: string;
+}
+export const WorkflowsWriteWorkflowsManagePathRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      path: S.String.pipe(T.Label()),
+      after: S.optional(S.String),
+      allow_unauthenticated: S.optional(S.Boolean),
+      cas: S.optional(S.Number),
+      cas_required: S.optional(S.Boolean),
+      description: S.optional(S.String),
+      limit: S.optional(S.Number),
+      workflow: S.String,
+    }).pipe(
+      T.Http({
+        method: "POST",
+        uri: "/sys/workflows/manage/{path}",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "WorkflowsWriteWorkflowsManagePathRequest",
+}) as any as S.Schema<WorkflowsWriteWorkflowsManagePathRequest>;
+
+export interface WorkflowsWriteWorkflowsManagePathResponse {
+  /** Whether this workflow can be accessed unauthenticated. */
+  allow_unauthenticated?: boolean;
+  /** Whether check and set support is required. */
+  cas_required?: boolean;
+  /** Workflow description. */
+  description?: string;
+  /** Version of the workflow. */
+  version?: number;
+  /** Workflow definition in HCL or JSON. */
+  workflow?: string;
+}
+export const WorkflowsWriteWorkflowsManagePathResponse =
+  /*@__PURE__*/ S.suspend(() =>
+    S.Struct({
+      allow_unauthenticated: S.optional(S.Boolean),
+      cas_required: S.optional(S.Boolean),
+      description: S.optional(S.String),
+      version: S.optional(S.Number),
+      workflow: S.optional(S.String),
+    }),
+  ).annotate({
+    identifier: "WorkflowsWriteWorkflowsManagePathResponse",
+  }) as any as S.Schema<WorkflowsWriteWorkflowsManagePathResponse>;
+
+export type DeleteWorkflowsManagePathError = OpenBaoOpError;
+/** Delete a workflow. */
+export const deleteWorkflowsManagePath: API.OperationMethod<
+  DeleteWorkflowsManagePathRequest,
+  DeleteWorkflowsManagePathResponse,
+  DeleteWorkflowsManagePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteWorkflowsManagePathRequest,
+  output: DeleteWorkflowsManagePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ReadWorkflowsManagePathError = OpenBaoOpError;
+/** Retrieve a workflow. */
+export const readWorkflowsManagePath: API.OperationMethod<
+  ReadWorkflowsManagePathRequest,
+  WorkflowsReadWorkflowsManagePathResponse,
+  ReadWorkflowsManagePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ReadWorkflowsManagePathRequest,
+  output: WorkflowsReadWorkflowsManagePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WorkflowsExecuteWriteWorkflowsExecutePathError = OpenBaoOpError;
+/** Execute the given workflow. */
+export const workflowsExecuteWriteWorkflowsExecutePath: API.OperationMethod<
+  WorkflowsExecuteWriteWorkflowsExecutePathRequest,
+  WorkflowsExecuteWriteWorkflowsExecutePathResponse,
+  WorkflowsExecuteWriteWorkflowsExecutePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WorkflowsExecuteWriteWorkflowsExecutePathRequest,
+  output: WorkflowsExecuteWriteWorkflowsExecutePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WorkflowsScanWorkflowsManageError = OpenBaoOpError;
+/** Scan (recursively list) workflows. */
+export const workflowsScanWorkflowsManage: API.OperationMethod<
+  WorkflowsScanWorkflowsManageRequest,
+  WorkflowsScanWorkflowsManageResponse,
+  WorkflowsScanWorkflowsManageError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WorkflowsScanWorkflowsManageRequest,
+  output: WorkflowsScanWorkflowsManageResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WorkflowsTraceWriteWorkflowsTracePathError = OpenBaoOpError;
+/** Execute the given workflow. */
+export const workflowsTraceWriteWorkflowsTracePath: API.OperationMethod<
+  WorkflowsTraceWriteWorkflowsTracePathRequest,
+  WorkflowsTraceWriteWorkflowsTracePathResponse,
+  WorkflowsTraceWriteWorkflowsTracePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WorkflowsTraceWriteWorkflowsTracePathRequest,
+  output: WorkflowsTraceWriteWorkflowsTracePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type WorkflowsWriteWorkflowsManagePathError = OpenBaoOpError;
+/** Create or update a workflow. */
+export const workflowsWriteWorkflowsManagePath: API.OperationMethod<
+  WorkflowsWriteWorkflowsManagePathRequest,
+  WorkflowsWriteWorkflowsManagePathResponse,
+  WorkflowsWriteWorkflowsManagePathError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: WorkflowsWriteWorkflowsManagePathRequest,
+  output: WorkflowsWriteWorkflowsManagePathResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));

package/src/traits.ts

@@ -0,0 +1,45 @@
+/**
+ * OpenBao SDK trait surface — hand-written.
+ *
+ * Re-exports the generic protocol traits from core so generated operations
+ * import everything from one place. OpenBao speaks plain token-REST JSON
+ * with a `data`-enveloped success body (unwrapped in `protocol.ts`), so
+ * there are no provider-specific traits.
+ */
+export {
+  Body,
+  Header,
+  Query,
+  Label,
+  Http,
+  ResponseCode,
+  HttpBody,
+  FormDataFile,
+  KeyDictionary,
+  UnionCases,
+  applyErrorMatchers,
+  getErrorMatchers,
+  type HttpTrait,
+  type ErrorMatcher,
+  bodySymbol,
+  headerSymbol,
+  querySymbol,
+  labelSymbol,
+  httpSymbol,
+  responseCodeSymbol,
+  httpBodySymbol,
+  formDataFileSymbol,
+  keyDictionarySymbol,
+  unionCasesSymbol,
+  errorMatchersSymbol,
+} from "@distilled.cloud/core/trait";
+
+// Bearer-REST protocol traits (sensitive strings, bare-payload responses).
+export {
+  SensitiveValue,
+  RawResponse,
+  RawResponseRoot,
+  sensitiveValueSymbol,
+  rawResponseSymbol,
+  rawResponseRootSymbol,
+} from "@distilled.cloud/core/protocol-rest";