@meetkai/mka1 0.55.14 → 0.55.16

package/src/models/operations/requestownerkeyrecovery.ts

@@ -0,0 +1,387 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type RequestOwnerKeyRecoveryRequestBody = {
+  reason: string;
+  userId?: string | undefined;
+  teamId?: string | undefined;
+};
+
+export type RequestOwnerKeyRecoveryRequest = {
+  id: string;
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  requestBody: RequestOwnerKeyRecoveryRequestBody;
+};
+
+export const RequestOwnerKeyRecoveryStatus = {
+  Pending: "pending",
+  Approved: "approved",
+  Rejected: "rejected",
+  Expired: "expired",
+} as const;
+export type RequestOwnerKeyRecoveryStatus = ClosedEnum<
+  typeof RequestOwnerKeyRecoveryStatus
+>;
+
+export type RequestedBy = {
+  id: string;
+  email: string | null;
+  name: string | null;
+};
+
+export type DecidedBy = {
+  id: string;
+  email: string | null;
+  name: string | null;
+};
+
+export type RequestT = {
+  id: string;
+  orgId: string;
+  orgName: string;
+  orgSlug: string;
+  targetUserId: string;
+  targetUserEmail: string | null;
+  teamId: string;
+  reason: string;
+  status: RequestOwnerKeyRecoveryStatus;
+  requestedBy: RequestedBy;
+  decidedBy: DecidedBy | null;
+  decidedAt: string | null;
+  expiresAt: string;
+  createdAt: string;
+  mintedKeyId: string | null;
+};
+
+/**
+ * Recovery requested; awaiting a second cluster admin
+ */
+export type RequestOwnerKeyRecoveryResponseBody = {
+  request: RequestT;
+};
+
+/** @internal */
+export const RequestOwnerKeyRecoveryRequestBody$inboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  reason: z.string(),
+  userId: z.string().optional(),
+  teamId: z.string().optional(),
+});
+/** @internal */
+export type RequestOwnerKeyRecoveryRequestBody$Outbound = {
+  reason: string;
+  userId?: string | undefined;
+  teamId?: string | undefined;
+};
+
+/** @internal */
+export const RequestOwnerKeyRecoveryRequestBody$outboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryRequestBody$Outbound,
+  z.ZodTypeDef,
+  RequestOwnerKeyRecoveryRequestBody
+> = z.object({
+  reason: z.string(),
+  userId: z.string().optional(),
+  teamId: z.string().optional(),
+});
+
+export function requestOwnerKeyRecoveryRequestBodyToJSON(
+  requestOwnerKeyRecoveryRequestBody: RequestOwnerKeyRecoveryRequestBody,
+): string {
+  return JSON.stringify(
+    RequestOwnerKeyRecoveryRequestBody$outboundSchema.parse(
+      requestOwnerKeyRecoveryRequestBody,
+    ),
+  );
+}
+export function requestOwnerKeyRecoveryRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestOwnerKeyRecoveryRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      RequestOwnerKeyRecoveryRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestOwnerKeyRecoveryRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequestOwnerKeyRecoveryRequest$inboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  "X-On-Behalf-Of": z.string().optional(),
+  RequestBody: z.lazy(() => RequestOwnerKeyRecoveryRequestBody$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "RequestBody": "requestBody",
+  });
+});
+/** @internal */
+export type RequestOwnerKeyRecoveryRequest$Outbound = {
+  id: string;
+  "X-On-Behalf-Of"?: string | undefined;
+  RequestBody: RequestOwnerKeyRecoveryRequestBody$Outbound;
+};
+
+/** @internal */
+export const RequestOwnerKeyRecoveryRequest$outboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryRequest$Outbound,
+  z.ZodTypeDef,
+  RequestOwnerKeyRecoveryRequest
+> = z.object({
+  id: z.string(),
+  xOnBehalfOf: z.string().optional(),
+  requestBody: z.lazy(() => RequestOwnerKeyRecoveryRequestBody$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    requestBody: "RequestBody",
+  });
+});
+
+export function requestOwnerKeyRecoveryRequestToJSON(
+  requestOwnerKeyRecoveryRequest: RequestOwnerKeyRecoveryRequest,
+): string {
+  return JSON.stringify(
+    RequestOwnerKeyRecoveryRequest$outboundSchema.parse(
+      requestOwnerKeyRecoveryRequest,
+    ),
+  );
+}
+export function requestOwnerKeyRecoveryRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestOwnerKeyRecoveryRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequestOwnerKeyRecoveryRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestOwnerKeyRecoveryRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequestOwnerKeyRecoveryStatus$inboundSchema: z.ZodNativeEnum<
+  typeof RequestOwnerKeyRecoveryStatus
+> = z.nativeEnum(RequestOwnerKeyRecoveryStatus);
+/** @internal */
+export const RequestOwnerKeyRecoveryStatus$outboundSchema: z.ZodNativeEnum<
+  typeof RequestOwnerKeyRecoveryStatus
+> = RequestOwnerKeyRecoveryStatus$inboundSchema;
+
+/** @internal */
+export const RequestedBy$inboundSchema: z.ZodType<
+  RequestedBy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  email: z.nullable(z.string()),
+  name: z.nullable(z.string()),
+});
+/** @internal */
+export type RequestedBy$Outbound = {
+  id: string;
+  email: string | null;
+  name: string | null;
+};
+
+/** @internal */
+export const RequestedBy$outboundSchema: z.ZodType<
+  RequestedBy$Outbound,
+  z.ZodTypeDef,
+  RequestedBy
+> = z.object({
+  id: z.string(),
+  email: z.nullable(z.string()),
+  name: z.nullable(z.string()),
+});
+
+export function requestedByToJSON(requestedBy: RequestedBy): string {
+  return JSON.stringify(RequestedBy$outboundSchema.parse(requestedBy));
+}
+export function requestedByFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestedBy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequestedBy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestedBy' from JSON`,
+  );
+}
+
+/** @internal */
+export const DecidedBy$inboundSchema: z.ZodType<
+  DecidedBy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  email: z.nullable(z.string()),
+  name: z.nullable(z.string()),
+});
+/** @internal */
+export type DecidedBy$Outbound = {
+  id: string;
+  email: string | null;
+  name: string | null;
+};
+
+/** @internal */
+export const DecidedBy$outboundSchema: z.ZodType<
+  DecidedBy$Outbound,
+  z.ZodTypeDef,
+  DecidedBy
+> = z.object({
+  id: z.string(),
+  email: z.nullable(z.string()),
+  name: z.nullable(z.string()),
+});
+
+export function decidedByToJSON(decidedBy: DecidedBy): string {
+  return JSON.stringify(DecidedBy$outboundSchema.parse(decidedBy));
+}
+export function decidedByFromJSON(
+  jsonString: string,
+): SafeParseResult<DecidedBy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DecidedBy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DecidedBy' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequestT$inboundSchema: z.ZodType<
+  RequestT,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  orgId: z.string(),
+  orgName: z.string(),
+  orgSlug: z.string(),
+  targetUserId: z.string(),
+  targetUserEmail: z.nullable(z.string()),
+  teamId: z.string(),
+  reason: z.string(),
+  status: RequestOwnerKeyRecoveryStatus$inboundSchema,
+  requestedBy: z.lazy(() => RequestedBy$inboundSchema),
+  decidedBy: z.nullable(z.lazy(() => DecidedBy$inboundSchema)),
+  decidedAt: z.nullable(z.string()),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+  mintedKeyId: z.nullable(z.string()),
+});
+/** @internal */
+export type RequestT$Outbound = {
+  id: string;
+  orgId: string;
+  orgName: string;
+  orgSlug: string;
+  targetUserId: string;
+  targetUserEmail: string | null;
+  teamId: string;
+  reason: string;
+  status: string;
+  requestedBy: RequestedBy$Outbound;
+  decidedBy: DecidedBy$Outbound | null;
+  decidedAt: string | null;
+  expiresAt: string;
+  createdAt: string;
+  mintedKeyId: string | null;
+};
+
+/** @internal */
+export const RequestT$outboundSchema: z.ZodType<
+  RequestT$Outbound,
+  z.ZodTypeDef,
+  RequestT
+> = z.object({
+  id: z.string(),
+  orgId: z.string(),
+  orgName: z.string(),
+  orgSlug: z.string(),
+  targetUserId: z.string(),
+  targetUserEmail: z.nullable(z.string()),
+  teamId: z.string(),
+  reason: z.string(),
+  status: RequestOwnerKeyRecoveryStatus$outboundSchema,
+  requestedBy: z.lazy(() => RequestedBy$outboundSchema),
+  decidedBy: z.nullable(z.lazy(() => DecidedBy$outboundSchema)),
+  decidedAt: z.nullable(z.string()),
+  expiresAt: z.string(),
+  createdAt: z.string(),
+  mintedKeyId: z.nullable(z.string()),
+});
+
+export function requestToJSON(requestT: RequestT): string {
+  return JSON.stringify(RequestT$outboundSchema.parse(requestT));
+}
+export function requestFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => RequestT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestT' from JSON`,
+  );
+}
+
+/** @internal */
+export const RequestOwnerKeyRecoveryResponseBody$inboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  request: z.lazy(() => RequestT$inboundSchema),
+});
+/** @internal */
+export type RequestOwnerKeyRecoveryResponseBody$Outbound = {
+  request: RequestT$Outbound;
+};
+
+/** @internal */
+export const RequestOwnerKeyRecoveryResponseBody$outboundSchema: z.ZodType<
+  RequestOwnerKeyRecoveryResponseBody$Outbound,
+  z.ZodTypeDef,
+  RequestOwnerKeyRecoveryResponseBody
+> = z.object({
+  request: z.lazy(() => RequestT$outboundSchema),
+});
+
+export function requestOwnerKeyRecoveryResponseBodyToJSON(
+  requestOwnerKeyRecoveryResponseBody: RequestOwnerKeyRecoveryResponseBody,
+): string {
+  return JSON.stringify(
+    RequestOwnerKeyRecoveryResponseBody$outboundSchema.parse(
+      requestOwnerKeyRecoveryResponseBody,
+    ),
+  );
+}
+export function requestOwnerKeyRecoveryResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<RequestOwnerKeyRecoveryResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      RequestOwnerKeyRecoveryResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RequestOwnerKeyRecoveryResponseBody' from JSON`,
+  );
+}

package/src/react-query/authApiKeyGetJwtFromKey.ts

@@ -39,6 +39,7 @@ export type AuthApiKeyGetJwtFromKeyMutationError =
   | errors.GetJwtFromKeyResponseBody
   | errors.GetJwtFromKeyAuthApiKeyResponseBody
   | errors.GetJwtFromKeyAuthApiKeyResponseResponseBody
+  | errors.GetJwtFromKeyAuthApiKeyResponse500ResponseBody
   | SDKError
   | ResponseValidationError
   | ConnectionError

package/src/react-query/authClusterApproveOwnerKeyRecovery.ts

@@ -0,0 +1,117 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { authClusterApproveOwnerKeyRecovery } from "../funcs/authClusterApproveOwnerKeyRecovery.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import * as errors from "../models/errors/index.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export type AuthClusterApproveOwnerKeyRecoveryMutationVariables = {
+  request: operations.ApproveOwnerKeyRecoveryRequest;
+  options?: RequestOptions;
+};
+
+export type AuthClusterApproveOwnerKeyRecoveryMutationData =
+  operations.ApproveOwnerKeyRecoveryResponseBody;
+
+export type AuthClusterApproveOwnerKeyRecoveryMutationError =
+  | errors.ApproveOwnerKeyRecoveryResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponseResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponse404ResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponse409ResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponse410ResponseBody
+  | errors.ApproveOwnerKeyRecoveryAuthClusterResponse429ResponseBody
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Approve an owner-key recovery
+ *
+ * @remarks
+ * Mint the owner key and mark the request approved. Needs a cluster admin's signed-in session; API keys are refused. The requester, and anyone who joined the Cluster org after the request was made, cannot approve. `token` is the per-recipient token from the approval email; when present it must belong to the caller.
+ */
+export function useAuthClusterApproveOwnerKeyRecoveryMutation(
+  options?: MutationHookOptions<
+    AuthClusterApproveOwnerKeyRecoveryMutationData,
+    AuthClusterApproveOwnerKeyRecoveryMutationError,
+    AuthClusterApproveOwnerKeyRecoveryMutationVariables
+  >,
+): UseMutationResult<
+  AuthClusterApproveOwnerKeyRecoveryMutationData,
+  AuthClusterApproveOwnerKeyRecoveryMutationError,
+  AuthClusterApproveOwnerKeyRecoveryMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildAuthClusterApproveOwnerKeyRecoveryMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyAuthClusterApproveOwnerKeyRecovery(): MutationKey {
+  return ["@meetkai/mka1", "cluster", "approveOwnerKeyRecovery"];
+}
+
+export function buildAuthClusterApproveOwnerKeyRecoveryMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions,
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: AuthClusterApproveOwnerKeyRecoveryMutationVariables,
+  ) => Promise<AuthClusterApproveOwnerKeyRecoveryMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyAuthClusterApproveOwnerKeyRecovery(),
+    mutationFn: function authClusterApproveOwnerKeyRecoveryMutationFn({
+      request,
+      options,
+    }): Promise<AuthClusterApproveOwnerKeyRecoveryMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(authClusterApproveOwnerKeyRecovery(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/react-query/authClusterGetOwnerKeyRecovery.core.ts

@@ -0,0 +1,76 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  QueryClient,
+  QueryFunctionContext,
+  QueryKey,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { authClusterGetOwnerKeyRecovery } from "../funcs/authClusterGetOwnerKeyRecovery.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+export type AuthClusterGetOwnerKeyRecoveryQueryData =
+  operations.GetOwnerKeyRecoveryResponseBody;
+
+export function prefetchAuthClusterGetOwnerKeyRecovery(
+  queryClient: QueryClient,
+  client$: SDKCore,
+  request: operations.GetOwnerKeyRecoveryRequest,
+  options?: RequestOptions,
+): Promise<void> {
+  return queryClient.prefetchQuery({
+    ...buildAuthClusterGetOwnerKeyRecoveryQuery(
+      client$,
+      request,
+      options,
+    ),
+  });
+}
+
+export function buildAuthClusterGetOwnerKeyRecoveryQuery(
+  client$: SDKCore,
+  request: operations.GetOwnerKeyRecoveryRequest,
+  options?: RequestOptions,
+): {
+  queryKey: QueryKey;
+  queryFn: (
+    context: QueryFunctionContext,
+  ) => Promise<AuthClusterGetOwnerKeyRecoveryQueryData>;
+} {
+  return {
+    queryKey: queryKeyAuthClusterGetOwnerKeyRecovery(request.id, {
+      xOnBehalfOf: request.xOnBehalfOf,
+    }),
+    queryFn: async function authClusterGetOwnerKeyRecoveryQueryFn(
+      ctx,
+    ): Promise<AuthClusterGetOwnerKeyRecoveryQueryData> {
+      const sig = combineSignals(
+        ctx.signal,
+        options?.signal,
+        options?.fetchOptions?.signal,
+      );
+      const mergedOptions = {
+        ...options?.fetchOptions,
+        ...options,
+        signal: sig,
+      };
+
+      return unwrapAsync(authClusterGetOwnerKeyRecovery(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}
+
+export function queryKeyAuthClusterGetOwnerKeyRecovery(
+  id: string,
+  parameters: { xOnBehalfOf?: string | undefined },
+): QueryKey {
+  return ["@meetkai/mka1", "cluster", "getOwnerKeyRecovery", id, parameters];
+}