@homeflare/distilled-openbao 0.2.0

package/src/services/entity.ts

@@ -0,0 +1,744 @@
+// 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 };
+
+/** Policies to be tied to the entity. */
+export type CreateEntityRequestPoliciesList = Array<string>;
+export const CreateEntityRequestPoliciesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<CreateEntityRequestPoliciesList>;
+
+export interface CreateEntityRequest {
+  /** 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 */
+  metadata?: unknown;
+  /** Name of the entity */
+  name?: string;
+  /** Policies to be tied to the entity. */
+  policies?: CreateEntityRequestPoliciesList;
+}
+export const CreateEntityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    disabled: S.optional(S.Boolean),
+    id: S.optional(S.String),
+    metadata: S.optional(S.Unknown),
+    name: S.optional(S.String),
+    policies: S.optional(CreateEntityRequestPoliciesList),
+  }).pipe(T.Http({ method: "POST", uri: "/identity/entity", code: 200 })),
+).annotate({
+  identifier: "CreateEntityRequest",
+}) as any as S.Schema<CreateEntityRequest>;
+
+export interface CreateEntityResponse {}
+export const CreateEntityResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "CreateEntityResponse",
+}) as any as S.Schema<CreateEntityResponse>;
+
+/** Entity IDs to delete */
+export type DeleteEntityBatchRequestEntityIdsList = Array<string>;
+export const DeleteEntityBatchRequestEntityIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<DeleteEntityBatchRequestEntityIdsList>;
+
+export interface DeleteEntityBatchRequest {
+  /** Entity IDs to delete */
+  entity_ids?: DeleteEntityBatchRequestEntityIdsList;
+}
+export const DeleteEntityBatchRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    entity_ids: S.optional(DeleteEntityBatchRequestEntityIdsList),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/identity/entity/batch-delete", code: 200 }),
+  ),
+).annotate({
+  identifier: "DeleteEntityBatchRequest",
+}) as any as S.Schema<DeleteEntityBatchRequest>;
+
+export interface DeleteEntityBatchResponse {}
+export const DeleteEntityBatchResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteEntityBatchResponse",
+}) as any as S.Schema<DeleteEntityBatchResponse>;
+
+export interface EntityCreateAliasRequest {
+  /** Entity ID to which this alias belongs */
+  canonical_id?: string;
+  /** User provided key-value pairs */
+  custom_metadata?: unknown;
+  /** 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;
+}
+export const EntityCreateAliasRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    canonical_id: S.optional(S.String),
+    custom_metadata: S.optional(S.Unknown),
+    entity_id: S.optional(S.String),
+    id: S.optional(S.String),
+    mount_accessor: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/identity/entity-alias", code: 200 })),
+).annotate({
+  identifier: "EntityCreateAliasRequest",
+}) as any as S.Schema<EntityCreateAliasRequest>;
+
+export interface EntityCreateAliasResponse {}
+export const EntityCreateAliasResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityCreateAliasResponse",
+}) as any as S.Schema<EntityCreateAliasResponse>;
+
+export interface EntityDeleteAliasByIdRequest {
+  /** ID of the alias */
+  id: string;
+}
+export const EntityDeleteAliasByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/identity/entity-alias/id/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EntityDeleteAliasByIdRequest",
+}) as any as S.Schema<EntityDeleteAliasByIdRequest>;
+
+export interface EntityDeleteAliasByIdResponse {}
+export const EntityDeleteAliasByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityDeleteAliasByIdResponse",
+}) as any as S.Schema<EntityDeleteAliasByIdResponse>;
+
+export interface EntityDeleteByIdRequest {
+  /** ID of the entity. If set, updates the corresponding existing entity. */
+  id: string;
+}
+export const EntityDeleteByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "DELETE", uri: "/identity/entity/id/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityDeleteByIdRequest",
+}) as any as S.Schema<EntityDeleteByIdRequest>;
+
+export interface EntityDeleteByIdResponse {}
+export const EntityDeleteByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityDeleteByIdResponse",
+}) as any as S.Schema<EntityDeleteByIdResponse>;
+
+export interface EntityDeleteByNameRequest {
+  /** Name of the entity */
+  name: string;
+}
+export const EntityDeleteByNameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/identity/entity/name/{name}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EntityDeleteByNameRequest",
+}) as any as S.Schema<EntityDeleteByNameRequest>;
+
+export interface EntityDeleteByNameResponse {}
+export const EntityDeleteByNameResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityDeleteByNameResponse",
+}) as any as S.Schema<EntityDeleteByNameResponse>;
+
+export type EntityListAliasesByIdRequestList = "true";
+export const EntityListAliasesByIdRequestList = S.String;
+
+export interface EntityListAliasesByIdRequest {
+  /** Must be set to `true` */
+  list: EntityListAliasesByIdRequestList | (string & {});
+}
+export const EntityListAliasesByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: EntityListAliasesByIdRequestList.pipe(T.Query()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/identity/entity-alias/id", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityListAliasesByIdRequest",
+}) as any as S.Schema<EntityListAliasesByIdRequest>;
+
+export interface EntityListAliasesByIdResponse {}
+export const EntityListAliasesByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityListAliasesByIdResponse",
+}) as any as S.Schema<EntityListAliasesByIdResponse>;
+
+export type EntityListByIdRequestList = "true";
+export const EntityListByIdRequestList = S.String;
+
+export interface EntityListByIdRequest {
+  /** Must be set to `true` */
+  list: EntityListByIdRequestList | (string & {});
+}
+export const EntityListByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: EntityListByIdRequestList.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/identity/entity/id", code: 200 })),
+).annotate({
+  identifier: "EntityListByIdRequest",
+}) as any as S.Schema<EntityListByIdRequest>;
+
+export interface EntityListByIdResponse {}
+export const EntityListByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityListByIdResponse",
+}) as any as S.Schema<EntityListByIdResponse>;
+
+export type EntityListByNameRequestList = "true";
+export const EntityListByNameRequestList = S.String;
+
+export interface EntityListByNameRequest {
+  /** Must be set to `true` */
+  list: EntityListByNameRequestList | (string & {});
+}
+export const EntityListByNameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    list: EntityListByNameRequestList.pipe(T.Query()),
+  }).pipe(T.Http({ method: "GET", uri: "/identity/entity/name", code: 200 })),
+).annotate({
+  identifier: "EntityListByNameRequest",
+}) as any as S.Schema<EntityListByNameRequest>;
+
+export interface EntityListByNameResponse {}
+export const EntityListByNameResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityListByNameResponse",
+}) as any as S.Schema<EntityListByNameResponse>;
+
+export 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;
+}
+export const EntityLookUpRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    alias_id: S.optional(S.String),
+    alias_mount_accessor: S.optional(S.String),
+    alias_name: S.optional(S.String),
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/identity/lookup/entity", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityLookUpRequest",
+}) as any as S.Schema<EntityLookUpRequest>;
+
+export interface EntityLookUpResponse {}
+export const EntityLookUpResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityLookUpResponse",
+}) as any as S.Schema<EntityLookUpResponse>;
+
+export interface EntityReadAliasByIdRequest {
+  /** ID of the alias */
+  id: string;
+}
+export const EntityReadAliasByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/identity/entity-alias/id/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityReadAliasByIdRequest",
+}) as any as S.Schema<EntityReadAliasByIdRequest>;
+
+export interface EntityReadAliasByIdResponse {}
+export const EntityReadAliasByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityReadAliasByIdResponse",
+}) as any as S.Schema<EntityReadAliasByIdResponse>;
+
+export interface EntityReadByIdRequest {
+  /** ID of the entity. If set, updates the corresponding existing entity. */
+  id: string;
+}
+export const EntityReadByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/identity/entity/id/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityReadByIdRequest",
+}) as any as S.Schema<EntityReadByIdRequest>;
+
+export interface EntityReadByIdResponse {}
+export const EntityReadByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityReadByIdResponse",
+}) as any as S.Schema<EntityReadByIdResponse>;
+
+export interface EntityReadByNameRequest {
+  /** Name of the entity */
+  name: string;
+}
+export const EntityReadByNameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/identity/entity/name/{name}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityReadByNameRequest",
+}) as any as S.Schema<EntityReadByNameRequest>;
+
+export interface EntityReadByNameResponse {}
+export const EntityReadByNameResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityReadByNameResponse",
+}) as any as S.Schema<EntityReadByNameResponse>;
+
+export interface EntityUpdateAliasByIdRequest {
+  /** ID of the alias */
+  id: string;
+  /** Entity ID to which this alias should be tied to */
+  canonical_id?: string;
+  /** User provided key-value pairs */
+  custom_metadata?: unknown;
+  /** 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;
+}
+export const EntityUpdateAliasByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    canonical_id: S.optional(S.String),
+    custom_metadata: S.optional(S.Unknown),
+    entity_id: S.optional(S.String),
+    mount_accessor: S.optional(S.String),
+    name: S.optional(S.String),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/identity/entity-alias/id/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "EntityUpdateAliasByIdRequest",
+}) as any as S.Schema<EntityUpdateAliasByIdRequest>;
+
+export interface EntityUpdateAliasByIdResponse {}
+export const EntityUpdateAliasByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityUpdateAliasByIdResponse",
+}) as any as S.Schema<EntityUpdateAliasByIdResponse>;
+
+/** Policies to be tied to the entity. */
+export type EntityUpdateByIdRequestPoliciesList = Array<string>;
+export const EntityUpdateByIdRequestPoliciesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EntityUpdateByIdRequestPoliciesList>;
+
+export interface EntityUpdateByIdRequest {
+  /** ID of the entity. If set, updates the corresponding existing entity. */
+  id: string;
+  /** 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 */
+  metadata?: unknown;
+  /** Name of the entity */
+  name?: string;
+  /** Policies to be tied to the entity. */
+  policies?: EntityUpdateByIdRequestPoliciesList;
+}
+export const EntityUpdateByIdRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+    disabled: S.optional(S.Boolean),
+    metadata: S.optional(S.Unknown),
+    name: S.optional(S.String),
+    policies: S.optional(EntityUpdateByIdRequestPoliciesList),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/identity/entity/id/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityUpdateByIdRequest",
+}) as any as S.Schema<EntityUpdateByIdRequest>;
+
+export interface EntityUpdateByIdResponse {}
+export const EntityUpdateByIdResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityUpdateByIdResponse",
+}) as any as S.Schema<EntityUpdateByIdResponse>;
+
+/** Policies to be tied to the entity. */
+export type EntityUpdateByNameRequestPoliciesList = Array<string>;
+export const EntityUpdateByNameRequestPoliciesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<EntityUpdateByNameRequestPoliciesList>;
+
+export interface EntityUpdateByNameRequest {
+  /** Name of the entity */
+  name: string;
+  /** 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 */
+  metadata?: unknown;
+  /** Policies to be tied to the entity. */
+  policies?: EntityUpdateByNameRequestPoliciesList;
+}
+export const EntityUpdateByNameRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    name: S.String.pipe(T.Label()),
+    disabled: S.optional(S.Boolean),
+    id: S.optional(S.String),
+    metadata: S.optional(S.Unknown),
+    policies: S.optional(EntityUpdateByNameRequestPoliciesList),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/identity/entity/name/{name}", code: 200 }),
+  ),
+).annotate({
+  identifier: "EntityUpdateByNameRequest",
+}) as any as S.Schema<EntityUpdateByNameRequest>;
+
+export interface EntityUpdateByNameResponse {}
+export const EntityUpdateByNameResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "EntityUpdateByNameResponse",
+}) as any as S.Schema<EntityUpdateByNameResponse>;
+
+/** Alias IDs to keep in case of conflicting aliases. Ignored if no conflicting aliases found */
+export type MergeEntityRequestConflictingAliasIdsToKeepList = Array<string>;
+export const MergeEntityRequestConflictingAliasIdsToKeepList =
+  /*@__PURE__*/ S.Array(
+    S.String,
+  ) as any as S.Schema<MergeEntityRequestConflictingAliasIdsToKeepList>;
+
+/** Entity IDs which need to get merged */
+export type MergeEntityRequestFromEntityIdsList = Array<string>;
+export const MergeEntityRequestFromEntityIdsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<MergeEntityRequestFromEntityIdsList>;
+
+export interface MergeEntityRequest {
+  /** Alias IDs to keep in case of conflicting aliases. Ignored if no conflicting aliases found */
+  conflicting_alias_ids_to_keep?: MergeEntityRequestConflictingAliasIdsToKeepList;
+  /** 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?: MergeEntityRequestFromEntityIdsList;
+  /** Entity ID into which all the other entities need to get merged */
+  to_entity_id?: string;
+}
+export const MergeEntityRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    conflicting_alias_ids_to_keep: S.optional(
+      MergeEntityRequestConflictingAliasIdsToKeepList,
+    ),
+    force: S.optional(S.Boolean),
+    from_entity_ids: S.optional(MergeEntityRequestFromEntityIdsList),
+    to_entity_id: S.optional(S.String),
+  }).pipe(T.Http({ method: "POST", uri: "/identity/entity/merge", code: 200 })),
+).annotate({
+  identifier: "MergeEntityRequest",
+}) as any as S.Schema<MergeEntityRequest>;
+
+export interface MergeEntityResponse {}
+export const MergeEntityResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "MergeEntityResponse",
+}) as any as S.Schema<MergeEntityResponse>;
+
+export type CreateEntityError = OpenBaoOpError;
+export const createEntity: API.OperationMethod<
+  CreateEntityRequest,
+  CreateEntityResponse,
+  CreateEntityError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: CreateEntityRequest,
+  output: CreateEntityResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteEntityBatchError = OpenBaoOpError;
+export const deleteEntityBatch: API.OperationMethod<
+  DeleteEntityBatchRequest,
+  DeleteEntityBatchResponse,
+  DeleteEntityBatchError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteEntityBatchRequest,
+  output: DeleteEntityBatchResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityCreateAliasError = OpenBaoOpError;
+export const entityCreateAlias: API.OperationMethod<
+  EntityCreateAliasRequest,
+  EntityCreateAliasResponse,
+  EntityCreateAliasError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityCreateAliasRequest,
+  output: EntityCreateAliasResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityDeleteAliasByIdError = OpenBaoOpError;
+export const entityDeleteAliasById: API.OperationMethod<
+  EntityDeleteAliasByIdRequest,
+  EntityDeleteAliasByIdResponse,
+  EntityDeleteAliasByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityDeleteAliasByIdRequest,
+  output: EntityDeleteAliasByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityDeleteByIdError = OpenBaoOpError;
+export const entityDeleteById: API.OperationMethod<
+  EntityDeleteByIdRequest,
+  EntityDeleteByIdResponse,
+  EntityDeleteByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityDeleteByIdRequest,
+  output: EntityDeleteByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityDeleteByNameError = OpenBaoOpError;
+export const entityDeleteByName: API.OperationMethod<
+  EntityDeleteByNameRequest,
+  EntityDeleteByNameResponse,
+  EntityDeleteByNameError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityDeleteByNameRequest,
+  output: EntityDeleteByNameResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityListAliasesByIdError = OpenBaoOpError;
+export const entityListAliasesById: API.OperationMethod<
+  EntityListAliasesByIdRequest,
+  EntityListAliasesByIdResponse,
+  EntityListAliasesByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityListAliasesByIdRequest,
+  output: EntityListAliasesByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityListByIdError = OpenBaoOpError;
+export const entityListById: API.OperationMethod<
+  EntityListByIdRequest,
+  EntityListByIdResponse,
+  EntityListByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityListByIdRequest,
+  output: EntityListByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityListByNameError = OpenBaoOpError;
+export const entityListByName: API.OperationMethod<
+  EntityListByNameRequest,
+  EntityListByNameResponse,
+  EntityListByNameError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityListByNameRequest,
+  output: EntityListByNameResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityLookUpError = OpenBaoOpError;
+export const entityLookUp: API.OperationMethod<
+  EntityLookUpRequest,
+  EntityLookUpResponse,
+  EntityLookUpError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityLookUpRequest,
+  output: EntityLookUpResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityReadAliasByIdError = OpenBaoOpError;
+export const entityReadAliasById: API.OperationMethod<
+  EntityReadAliasByIdRequest,
+  EntityReadAliasByIdResponse,
+  EntityReadAliasByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityReadAliasByIdRequest,
+  output: EntityReadAliasByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityReadByIdError = OpenBaoOpError;
+export const entityReadById: API.OperationMethod<
+  EntityReadByIdRequest,
+  EntityReadByIdResponse,
+  EntityReadByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityReadByIdRequest,
+  output: EntityReadByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityReadByNameError = OpenBaoOpError;
+export const entityReadByName: API.OperationMethod<
+  EntityReadByNameRequest,
+  EntityReadByNameResponse,
+  EntityReadByNameError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityReadByNameRequest,
+  output: EntityReadByNameResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityUpdateAliasByIdError = OpenBaoOpError;
+export const entityUpdateAliasById: API.OperationMethod<
+  EntityUpdateAliasByIdRequest,
+  EntityUpdateAliasByIdResponse,
+  EntityUpdateAliasByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityUpdateAliasByIdRequest,
+  output: EntityUpdateAliasByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityUpdateByIdError = OpenBaoOpError;
+export const entityUpdateById: API.OperationMethod<
+  EntityUpdateByIdRequest,
+  EntityUpdateByIdResponse,
+  EntityUpdateByIdError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityUpdateByIdRequest,
+  output: EntityUpdateByIdResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type EntityUpdateByNameError = OpenBaoOpError;
+export const entityUpdateByName: API.OperationMethod<
+  EntityUpdateByNameRequest,
+  EntityUpdateByNameResponse,
+  EntityUpdateByNameError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: EntityUpdateByNameRequest,
+  output: EntityUpdateByNameResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MergeEntityError = OpenBaoOpError;
+export const mergeEntity: API.OperationMethod<
+  MergeEntityRequest,
+  MergeEntityResponse,
+  MergeEntityError,
+  OpenBaoOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MergeEntityRequest,
+  output: MergeEntityResponse,
+  errors: [],
+  protocol: OpenBaoProtocol,
+  retry: Retry.Retry,
+}));