/*
 * 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 {
  collectExtraKeys as collectExtraKeys$,
  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 AcceptClusterInviteRequestBody = {
  token: string;
  email: string;
  name?: string | undefined;
  password?: string | undefined;
  orgName: string;
  orgSlug?: string | undefined;
  logo?: string | undefined;
  passwordless?: boolean | undefined;
  issueApiKey?: boolean | undefined;
};

export type AcceptClusterInviteRequest = {
  /**
   * Optional external end-user identifier forwarded by the API gateway.
   */
  xOnBehalfOf?: string | undefined;
  requestBody?: AcceptClusterInviteRequestBody | undefined;
};

export type User = {
  id: string;
  additionalProperties?: { [k: string]: any } | undefined;
};

export type Organization = {
  id: string;
  slug: string;
  additionalProperties?: { [k: string]: any } | undefined;
};

export const ApiKeyUserType = {
  User: "user",
  ServiceAccount: "service-account",
} as const;
export type ApiKeyUserType = ClosedEnum<typeof ApiKeyUserType>;

export type AcceptClusterInviteApiKey = {
  id: string;
  name?: string | null | undefined;
  key?: string | undefined;
  prefix?: string | null | undefined;
  start?: string | null | undefined;
  userId: string;
  userType: ApiKeyUserType;
  orgId: string | null;
  teamId: string | null;
  scopes: Array<string>;
  expiresAt?: string | null | undefined;
};

/**
 * Organization created
 */
export type AcceptClusterInviteResponseBody = {
  message: string;
  user: User;
  organization: Organization;
  apiKey: AcceptClusterInviteApiKey | null;
};

/** @internal */
export const AcceptClusterInviteRequestBody$inboundSchema: z.ZodType<
  AcceptClusterInviteRequestBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  token: z.string(),
  email: z.string(),
  name: z.string().optional(),
  password: z.string().optional(),
  orgName: z.string(),
  orgSlug: z.string().optional(),
  logo: z.string().optional(),
  passwordless: z.boolean().optional(),
  issueApiKey: z.boolean().optional(),
});
/** @internal */
export type AcceptClusterInviteRequestBody$Outbound = {
  token: string;
  email: string;
  name?: string | undefined;
  password?: string | undefined;
  orgName: string;
  orgSlug?: string | undefined;
  logo?: string | undefined;
  passwordless?: boolean | undefined;
  issueApiKey?: boolean | undefined;
};

/** @internal */
export const AcceptClusterInviteRequestBody$outboundSchema: z.ZodType<
  AcceptClusterInviteRequestBody$Outbound,
  z.ZodTypeDef,
  AcceptClusterInviteRequestBody
> = z.object({
  token: z.string(),
  email: z.string(),
  name: z.string().optional(),
  password: z.string().optional(),
  orgName: z.string(),
  orgSlug: z.string().optional(),
  logo: z.string().optional(),
  passwordless: z.boolean().optional(),
  issueApiKey: z.boolean().optional(),
});

export function acceptClusterInviteRequestBodyToJSON(
  acceptClusterInviteRequestBody: AcceptClusterInviteRequestBody,
): string {
  return JSON.stringify(
    AcceptClusterInviteRequestBody$outboundSchema.parse(
      acceptClusterInviteRequestBody,
    ),
  );
}
export function acceptClusterInviteRequestBodyFromJSON(
  jsonString: string,
): SafeParseResult<AcceptClusterInviteRequestBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AcceptClusterInviteRequestBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AcceptClusterInviteRequestBody' from JSON`,
  );
}

/** @internal */
export const AcceptClusterInviteRequest$inboundSchema: z.ZodType<
  AcceptClusterInviteRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  "X-On-Behalf-Of": z.string().optional(),
  RequestBody: z.lazy(() => AcceptClusterInviteRequestBody$inboundSchema)
    .optional(),
}).transform((v) => {
  return remap$(v, {
    "X-On-Behalf-Of": "xOnBehalfOf",
    "RequestBody": "requestBody",
  });
});
/** @internal */
export type AcceptClusterInviteRequest$Outbound = {
  "X-On-Behalf-Of"?: string | undefined;
  RequestBody?: AcceptClusterInviteRequestBody$Outbound | undefined;
};

/** @internal */
export const AcceptClusterInviteRequest$outboundSchema: z.ZodType<
  AcceptClusterInviteRequest$Outbound,
  z.ZodTypeDef,
  AcceptClusterInviteRequest
> = z.object({
  xOnBehalfOf: z.string().optional(),
  requestBody: z.lazy(() => AcceptClusterInviteRequestBody$outboundSchema)
    .optional(),
}).transform((v) => {
  return remap$(v, {
    xOnBehalfOf: "X-On-Behalf-Of",
    requestBody: "RequestBody",
  });
});

export function acceptClusterInviteRequestToJSON(
  acceptClusterInviteRequest: AcceptClusterInviteRequest,
): string {
  return JSON.stringify(
    AcceptClusterInviteRequest$outboundSchema.parse(acceptClusterInviteRequest),
  );
}
export function acceptClusterInviteRequestFromJSON(
  jsonString: string,
): SafeParseResult<AcceptClusterInviteRequest, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AcceptClusterInviteRequest$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AcceptClusterInviteRequest' from JSON`,
  );
}

/** @internal */
export const User$inboundSchema: z.ZodType<User, z.ZodTypeDef, unknown> =
  collectExtraKeys$(
    z.object({
      id: z.string(),
    }).catchall(z.any()),
    "additionalProperties",
    true,
  );
/** @internal */
export type User$Outbound = {
  id: string;
  [additionalProperties: string]: unknown;
};

/** @internal */
export const User$outboundSchema: z.ZodType<User$Outbound, z.ZodTypeDef, User> =
  z.object({
    id: z.string(),
    additionalProperties: z.record(z.any()).optional(),
  }).transform((v) => {
    return {
      ...v.additionalProperties,
      ...remap$(v, {
        additionalProperties: null,
      }),
    };
  });

export function userToJSON(user: User): string {
  return JSON.stringify(User$outboundSchema.parse(user));
}
export function userFromJSON(
  jsonString: string,
): SafeParseResult<User, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => User$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'User' from JSON`,
  );
}

/** @internal */
export const Organization$inboundSchema: z.ZodType<
  Organization,
  z.ZodTypeDef,
  unknown
> = collectExtraKeys$(
  z.object({
    id: z.string(),
    slug: z.string(),
  }).catchall(z.any()),
  "additionalProperties",
  true,
);
/** @internal */
export type Organization$Outbound = {
  id: string;
  slug: string;
  [additionalProperties: string]: unknown;
};

/** @internal */
export const Organization$outboundSchema: z.ZodType<
  Organization$Outbound,
  z.ZodTypeDef,
  Organization
> = z.object({
  id: z.string(),
  slug: z.string(),
  additionalProperties: z.record(z.any()).optional(),
}).transform((v) => {
  return {
    ...v.additionalProperties,
    ...remap$(v, {
      additionalProperties: null,
    }),
  };
});

export function organizationToJSON(organization: Organization): string {
  return JSON.stringify(Organization$outboundSchema.parse(organization));
}
export function organizationFromJSON(
  jsonString: string,
): SafeParseResult<Organization, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Organization$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Organization' from JSON`,
  );
}

/** @internal */
export const ApiKeyUserType$inboundSchema: z.ZodNativeEnum<
  typeof ApiKeyUserType
> = z.nativeEnum(ApiKeyUserType);
/** @internal */
export const ApiKeyUserType$outboundSchema: z.ZodNativeEnum<
  typeof ApiKeyUserType
> = ApiKeyUserType$inboundSchema;

/** @internal */
export const AcceptClusterInviteApiKey$inboundSchema: z.ZodType<
  AcceptClusterInviteApiKey,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  name: z.nullable(z.string()).optional(),
  key: z.string().optional(),
  prefix: z.nullable(z.string()).optional(),
  start: z.nullable(z.string()).optional(),
  userId: z.string(),
  userType: ApiKeyUserType$inboundSchema,
  orgId: z.nullable(z.string()),
  teamId: z.nullable(z.string()),
  scopes: z.array(z.string()),
  expiresAt: z.nullable(z.string()).optional(),
});
/** @internal */
export type AcceptClusterInviteApiKey$Outbound = {
  id: string;
  name?: string | null | undefined;
  key?: string | undefined;
  prefix?: string | null | undefined;
  start?: string | null | undefined;
  userId: string;
  userType: string;
  orgId: string | null;
  teamId: string | null;
  scopes: Array<string>;
  expiresAt?: string | null | undefined;
};

/** @internal */
export const AcceptClusterInviteApiKey$outboundSchema: z.ZodType<
  AcceptClusterInviteApiKey$Outbound,
  z.ZodTypeDef,
  AcceptClusterInviteApiKey
> = z.object({
  id: z.string(),
  name: z.nullable(z.string()).optional(),
  key: z.string().optional(),
  prefix: z.nullable(z.string()).optional(),
  start: z.nullable(z.string()).optional(),
  userId: z.string(),
  userType: ApiKeyUserType$outboundSchema,
  orgId: z.nullable(z.string()),
  teamId: z.nullable(z.string()),
  scopes: z.array(z.string()),
  expiresAt: z.nullable(z.string()).optional(),
});

export function acceptClusterInviteApiKeyToJSON(
  acceptClusterInviteApiKey: AcceptClusterInviteApiKey,
): string {
  return JSON.stringify(
    AcceptClusterInviteApiKey$outboundSchema.parse(acceptClusterInviteApiKey),
  );
}
export function acceptClusterInviteApiKeyFromJSON(
  jsonString: string,
): SafeParseResult<AcceptClusterInviteApiKey, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AcceptClusterInviteApiKey$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AcceptClusterInviteApiKey' from JSON`,
  );
}

/** @internal */
export const AcceptClusterInviteResponseBody$inboundSchema: z.ZodType<
  AcceptClusterInviteResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  message: z.string(),
  user: z.lazy(() => User$inboundSchema),
  organization: z.lazy(() => Organization$inboundSchema),
  apiKey: z.nullable(z.lazy(() => AcceptClusterInviteApiKey$inboundSchema)),
});
/** @internal */
export type AcceptClusterInviteResponseBody$Outbound = {
  message: string;
  user: User$Outbound;
  organization: Organization$Outbound;
  apiKey: AcceptClusterInviteApiKey$Outbound | null;
};

/** @internal */
export const AcceptClusterInviteResponseBody$outboundSchema: z.ZodType<
  AcceptClusterInviteResponseBody$Outbound,
  z.ZodTypeDef,
  AcceptClusterInviteResponseBody
> = z.object({
  message: z.string(),
  user: z.lazy(() => User$outboundSchema),
  organization: z.lazy(() => Organization$outboundSchema),
  apiKey: z.nullable(z.lazy(() => AcceptClusterInviteApiKey$outboundSchema)),
});

export function acceptClusterInviteResponseBodyToJSON(
  acceptClusterInviteResponseBody: AcceptClusterInviteResponseBody,
): string {
  return JSON.stringify(
    AcceptClusterInviteResponseBody$outboundSchema.parse(
      acceptClusterInviteResponseBody,
    ),
  );
}
export function acceptClusterInviteResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<AcceptClusterInviteResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => AcceptClusterInviteResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'AcceptClusterInviteResponseBody' from JSON`,
  );
}