@agentuity/core 1.0.40 → 1.0.42

package/src/services/oauth/clients.ts

@@ -0,0 +1,161 @@
+import { APIClient } from '../api.ts';
+import { OAuthResponseError } from './util.ts';
+import {
+	OAuthClientCreateRequestSchema,
+	OAuthClientCreateResponseSchema,
+	OAuthClientDeleteResponseSchema,
+	OAuthClientGetResponseSchema,
+	OAuthClientListResponseSchema,
+	OAuthClientRevokeAllUsersResponseSchema,
+	OAuthClientRevokeUserResponseSchema,
+	OAuthClientRotateSecretResponseSchema,
+	OAuthClientUpdateRequestSchema,
+	OAuthClientUpdateResponseSchema,
+	OAuthClientUsersResponseSchema,
+	type OAuthClientCreateData,
+	type OAuthClientCreateRequest,
+	type OAuthClientListItem,
+	type OAuthClientUpdateData,
+	type OAuthClientUpdateRequest,
+	type OAuthConsentGrant,
+	type OAuthRotateSecretData,
+} from './types.ts';
+
+export async function oauthClientList(client: APIClient): Promise<OAuthClientListItem[]> {
+	const resp = await client.get('/oidc/clients', OAuthClientListResponseSchema);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientGet(client: APIClient, id: string): Promise<OAuthClientListItem> {
+	const resp = await client.get(
+		`/oidc/clients/${encodeURIComponent(id)}`,
+		OAuthClientGetResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientCreate(
+	client: APIClient,
+	request: OAuthClientCreateRequest
+): Promise<OAuthClientCreateData> {
+	const resp = await client.post(
+		'/oidc/clients',
+		request,
+		OAuthClientCreateResponseSchema,
+		OAuthClientCreateRequestSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientUpdate(
+	client: APIClient,
+	id: string,
+	request: OAuthClientUpdateRequest
+): Promise<OAuthClientUpdateData> {
+	const resp = await client.put(
+		`/oidc/clients/${encodeURIComponent(id)}`,
+		request,
+		OAuthClientUpdateResponseSchema,
+		OAuthClientUpdateRequestSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientDelete(client: APIClient, id: string): Promise<{ deleted: true }> {
+	const resp = await client.delete(
+		`/oidc/clients/${encodeURIComponent(id)}`,
+		OAuthClientDeleteResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientRotateSecret(
+	client: APIClient,
+	id: string
+): Promise<OAuthRotateSecretData> {
+	const resp = await client.post(
+		`/oidc/clients/${encodeURIComponent(id)}/rotate-secret`,
+		undefined,
+		OAuthClientRotateSecretResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientUsers(
+	client: APIClient,
+	id: string
+): Promise<OAuthConsentGrant[]> {
+	const resp = await client.get(
+		`/oidc/clients/${encodeURIComponent(id)}/users`,
+		OAuthClientUsersResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientRevokeAllUsers(
+	client: APIClient,
+	id: string
+): Promise<{ deleted: true }> {
+	const resp = await client.delete(
+		`/oidc/clients/${encodeURIComponent(id)}/users`,
+		OAuthClientRevokeAllUsersResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthClientRevokeUser(
+	client: APIClient,
+	id: string,
+	userId: string
+): Promise<{ deleted: true }> {
+	const resp = await client.delete(
+		`/oidc/clients/${encodeURIComponent(id)}/users/${encodeURIComponent(userId)}`,
+		OAuthClientRevokeUserResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}

package/src/services/oauth/consent.ts

@@ -0,0 +1,33 @@
+import { APIClient } from '../api.ts';
+import {
+	OAuthUserConsentResponseSchema,
+	OAuthUserConsentRevokeResponseSchema,
+	type OAuthUserConsent,
+} from './types.ts';
+import { OAuthResponseError } from './util.ts';
+
+export async function oauthUserConsent(client: APIClient): Promise<OAuthUserConsent[]> {
+	const resp = await client.get('/oidc/user/consent', OAuthUserConsentResponseSchema);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}
+
+export async function oauthUserConsentRevoke(
+	client: APIClient,
+	clientId: string
+): Promise<{ deleted: true }> {
+	const resp = await client.delete(
+		`/oidc/user/consent/${encodeURIComponent(clientId)}`,
+		OAuthUserConsentRevokeResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}

package/src/services/oauth/index.ts

@@ -0,0 +1,8 @@
+export * from './types.ts';
+export * from './clients.ts';
+export * from './activity.ts';
+export * from './consent.ts';
+export * from './scopes.ts';
+export * from './members.ts';
+export * from './keys.ts';
+export * from './util.ts';

package/src/services/oauth/keys.ts

@@ -0,0 +1,13 @@
+import { APIClient } from '../api.ts';
+import { OAuthKeysRotateResponseSchema } from './types.ts';
+import { OAuthResponseError } from './util.ts';
+
+export async function oauthKeysRotate(client: APIClient): Promise<{ rotated: true }> {
+	const resp = await client.post('/oidc/keys/rotate', undefined, OAuthKeysRotateResponseSchema);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}

package/src/services/oauth/members.ts

@@ -0,0 +1,13 @@
+import { APIClient } from '../api.ts';
+import { OAuthOrgMembersResponseSchema, type OAuthOrgMember } from './types.ts';
+import { OAuthResponseError } from './util.ts';
+
+export async function oauthOrgMembers(client: APIClient): Promise<OAuthOrgMember[]> {
+	const resp = await client.get('/oidc/org/members', OAuthOrgMembersResponseSchema);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}

package/src/services/oauth/scopes.ts

@@ -0,0 +1,13 @@
+import { APIClient } from '../api.ts';
+import { OAuthScopesResponseSchema, type OAuthScopesData } from './types.ts';
+import { OAuthResponseError } from './util.ts';
+
+export async function oauthScopes(client: APIClient): Promise<OAuthScopesData> {
+	const resp = await client.get('/oidc/scopes', OAuthScopesResponseSchema);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new OAuthResponseError({ message: resp.message });
+}

package/src/services/oauth/types.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+import { APIResponseSchema } from '../api.ts';
+
+export const OAuthClientSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	homepage_url: z.string(),
+	icon: z.string().nullable().optional(),
+	client_type: z.enum(['public', 'confidential']),
+	redirect_uris: z.array(z.string()),
+	post_logout_redirect_uris: z.array(z.string()),
+	grant_types: z.array(z.string()),
+	response_types: z.array(z.string()),
+	scopes: z.array(z.string()),
+	org_id: z.string().optional(),
+	project_id: z.string().optional(),
+	access_token_lifetime_seconds: z.number().optional(),
+	refresh_token_lifetime_seconds: z.number().optional(),
+	id_token_lifetime_seconds: z.number().optional(),
+	allowed_user_ids: z.array(z.string()),
+	created_at: z.string(),
+	updated_at: z.string(),
+});
+
+export type OAuthClient = z.infer<typeof OAuthClientSchema>;
+
+export const OAuthClientListItemSchema = OAuthClientSchema.extend({
+	user_count: z.number(),
+	last_activity: z.string().nullable().optional(),
+	link: z.string(),
+});
+
+export type OAuthClientListItem = z.infer<typeof OAuthClientListItemSchema>;
+
+export const OAuthClientCreateRequestSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	homepage_url: z.string(),
+	icon: z.string().nullable().optional(),
+	client_type: z.enum(['public', 'confidential']).optional(),
+	redirect_uris: z.array(z.string()).optional(),
+	post_logout_redirect_uris: z.array(z.string()).optional(),
+	grant_types: z.array(z.string()).optional(),
+	response_types: z.array(z.string()).optional(),
+	scopes: z.array(z.string()).optional(),
+	project_id: z.string().optional(),
+	access_token_lifetime_seconds: z.number().optional(),
+	refresh_token_lifetime_seconds: z.number().optional(),
+	id_token_lifetime_seconds: z.number().optional(),
+	allowed_user_ids: z.array(z.string()).optional(),
+});
+
+export type OAuthClientCreateRequest = z.infer<typeof OAuthClientCreateRequestSchema>;
+
+export const OAuthClientCreateDataSchema = z.object({
+	client: OAuthClientSchema,
+	client_secret: z.string(),
+});
+
+export type OAuthClientCreateData = z.infer<typeof OAuthClientCreateDataSchema>;
+
+export const OAuthClientUpdateRequestSchema = z.object({
+	name: z.string().optional(),
+	description: z.string().optional(),
+	homepage_url: z.string().optional(),
+	icon: z.string().nullable().optional(),
+	client_type: z.enum(['public', 'confidential']).optional(),
+	redirect_uris: z.array(z.string()).optional(),
+	post_logout_redirect_uris: z.array(z.string()).optional(),
+	grant_types: z.array(z.string()).optional(),
+	response_types: z.array(z.string()).optional(),
+	scopes: z.array(z.string()).optional(),
+	project_id: z.string().optional(),
+	access_token_lifetime_seconds: z.number().optional(),
+	refresh_token_lifetime_seconds: z.number().optional(),
+	id_token_lifetime_seconds: z.number().optional(),
+	allowed_user_ids: z.array(z.string()).optional(),
+});
+
+export type OAuthClientUpdateRequest = z.infer<typeof OAuthClientUpdateRequestSchema>;
+
+export const OAuthClientUpdateDataSchema = z.object({
+	client: OAuthClientSchema,
+	client_secret: z.string().optional(),
+});
+
+export type OAuthClientUpdateData = z.infer<typeof OAuthClientUpdateDataSchema>;
+
+export const OAuthRotateSecretDataSchema = z.object({
+	client_id: z.string(),
+	client_secret: z.string(),
+});
+
+export type OAuthRotateSecretData = z.infer<typeof OAuthRotateSecretDataSchema>;
+
+export const OAuthDeletedDataSchema = z.object({
+	deleted: z.literal(true),
+});
+
+export type OAuthDeletedData = z.infer<typeof OAuthDeletedDataSchema>;
+
+export const OAuthClientActivityItemSchema = z.object({
+	activity_date: z.string(),
+	total_access: z.number(),
+	unique_users: z.number(),
+});
+
+export type OAuthClientActivityItem = z.infer<typeof OAuthClientActivityItemSchema>;
+
+export const OAuthBulkActivityItemSchema = z.object({
+	client_id: z.string(),
+	activity_date: z.string(),
+	unique_users: z.number(),
+});
+
+export type OAuthBulkActivityItem = z.infer<typeof OAuthBulkActivityItemSchema>;
+
+export const OAuthConsentGrantSchema = z.object({
+	user_id: z.string(),
+	scopes: z.array(z.string()),
+	created_at: z.string(),
+	updated_at: z.string(),
+});
+
+export type OAuthConsentGrant = z.infer<typeof OAuthConsentGrantSchema>;
+
+export const OAuthUserConsentSchema = z.object({
+	client_id: z.string(),
+	scopes: z.array(z.string()),
+	created_at: z.string(),
+	updated_at: z.string(),
+	client_name: z.string(),
+	client_description: z.string(),
+	client_icon: z.string().nullable(),
+	client_homepage_url: z.string(),
+});
+
+export type OAuthUserConsent = z.infer<typeof OAuthUserConsentSchema>;
+
+export const OAuthScopeSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	consent_title: z.string(),
+	consent_description: z.string(),
+	sensitive: z.boolean(),
+	required: z.boolean(),
+	default: z.boolean(),
+});
+
+export type OAuthScope = z.infer<typeof OAuthScopeSchema>;
+
+export const OAuthPermissionLevelSchema = z.object({
+	label: z.string(),
+	value: z.string(),
+	scopes: z.array(z.string()),
+});
+
+export type OAuthPermissionLevel = z.infer<typeof OAuthPermissionLevelSchema>;
+
+export const OAuthPermissionGroupSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	levels: z.array(OAuthPermissionLevelSchema),
+});
+
+export type OAuthPermissionGroup = z.infer<typeof OAuthPermissionGroupSchema>;
+
+export const OAuthPermissionCategorySchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	groups: z.array(OAuthPermissionGroupSchema),
+});
+
+export type OAuthPermissionCategory = z.infer<typeof OAuthPermissionCategorySchema>;
+
+export const OAuthScopesDataSchema = z.object({
+	scopes: z.array(OAuthScopeSchema),
+	permissions: z.array(OAuthPermissionCategorySchema),
+});
+
+export type OAuthScopesData = z.infer<typeof OAuthScopesDataSchema>;
+
+export const OAuthOrgMemberSchema = z.object({
+	id: z.string(),
+	first_name: z.string().nullable(),
+	last_name: z.string().nullable(),
+	email: z.string().nullable(),
+	photo_url: z.string().nullable(),
+	role: z.string(),
+});
+
+export type OAuthOrgMember = z.infer<typeof OAuthOrgMemberSchema>;
+
+export const OAuthKeyRotatedDataSchema = z.object({
+	rotated: z.literal(true),
+});
+
+export type OAuthKeyRotatedData = z.infer<typeof OAuthKeyRotatedDataSchema>;
+
+export const OAuthClientListResponseSchema = APIResponseSchema(z.array(OAuthClientListItemSchema));
+export const OAuthClientGetResponseSchema = APIResponseSchema(OAuthClientListItemSchema);
+export const OAuthClientCreateResponseSchema = APIResponseSchema(OAuthClientCreateDataSchema);
+export const OAuthClientUpdateResponseSchema = APIResponseSchema(OAuthClientUpdateDataSchema);
+export const OAuthClientDeleteResponseSchema = APIResponseSchema(OAuthDeletedDataSchema);
+export const OAuthClientRotateSecretResponseSchema = APIResponseSchema(OAuthRotateSecretDataSchema);
+export const OAuthClientUsersResponseSchema = APIResponseSchema(z.array(OAuthConsentGrantSchema));
+export const OAuthClientRevokeAllUsersResponseSchema = APIResponseSchema(OAuthDeletedDataSchema);
+export const OAuthClientRevokeUserResponseSchema = APIResponseSchema(OAuthDeletedDataSchema);
+export const OAuthClientActivityResponseSchema = APIResponseSchema(
+	z.array(OAuthClientActivityItemSchema)
+);
+export const OAuthBulkActivityResponseSchema = APIResponseSchema(
+	z.array(OAuthBulkActivityItemSchema)
+);
+export const OAuthUserConsentResponseSchema = APIResponseSchema(z.array(OAuthUserConsentSchema));
+export const OAuthUserConsentRevokeResponseSchema = APIResponseSchema(OAuthDeletedDataSchema);
+export const OAuthScopesResponseSchema = APIResponseSchema(OAuthScopesDataSchema);
+export const OAuthOrgMembersResponseSchema = APIResponseSchema(z.array(OAuthOrgMemberSchema));
+export const OAuthKeysRotateResponseSchema = APIResponseSchema(OAuthKeyRotatedDataSchema);
+
+export type OAuthClientListResponse = z.infer<typeof OAuthClientListResponseSchema>;
+export type OAuthClientGetResponse = z.infer<typeof OAuthClientGetResponseSchema>;
+export type OAuthClientCreateResponse = z.infer<typeof OAuthClientCreateResponseSchema>;
+export type OAuthClientUpdateResponse = z.infer<typeof OAuthClientUpdateResponseSchema>;
+export type OAuthClientDeleteResponse = z.infer<typeof OAuthClientDeleteResponseSchema>;
+export type OAuthClientRotateSecretResponse = z.infer<typeof OAuthClientRotateSecretResponseSchema>;
+export type OAuthClientUsersResponse = z.infer<typeof OAuthClientUsersResponseSchema>;
+export type OAuthClientRevokeAllUsersResponse = z.infer<
+	typeof OAuthClientRevokeAllUsersResponseSchema
+>;
+export type OAuthClientRevokeUserResponse = z.infer<typeof OAuthClientRevokeUserResponseSchema>;
+export type OAuthClientActivityResponse = z.infer<typeof OAuthClientActivityResponseSchema>;
+export type OAuthBulkActivityResponse = z.infer<typeof OAuthBulkActivityResponseSchema>;
+export type OAuthUserConsentResponse = z.infer<typeof OAuthUserConsentResponseSchema>;
+export type OAuthUserConsentRevokeResponse = z.infer<typeof OAuthUserConsentRevokeResponseSchema>;
+export type OAuthScopesResponse = z.infer<typeof OAuthScopesResponseSchema>;
+export type OAuthOrgMembersResponse = z.infer<typeof OAuthOrgMembersResponseSchema>;
+export type OAuthKeysRotateResponse = z.infer<typeof OAuthKeysRotateResponseSchema>;

package/src/services/oauth/util.ts

@@ -0,0 +1,3 @@
+import { StructuredError } from '../../error.ts';
+
+export const OAuthResponseError = StructuredError('OAuthResponseError');

package/src/services/org/api-reference.ts

@@ -0,0 +1,148 @@
+import { OrgEnvDeleteRequestSchema } from './env-delete.ts';
+import { OrgEnvDataSchema } from './env-get.ts';
+import { OrgEnvUpdateRequestSchema } from './env-update.ts';
+import { OrgInfoApiSchema } from './types.ts';
+import type { Service } from '../api-reference.ts';
+
+const service: Service = {
+	name: 'Organizations',
+	slug: 'organizations',
+	description: 'Manage organizations, environment variables, and org-level resources',
+	endpoints: [
+		{
+			id: 'list-organizations',
+			title: 'List Organizations',
+			method: 'GET',
+			path: '/cli/organization',
+			description: 'List all organizations the authenticated user belongs to.',
+			pathParams: [],
+			queryParams: [],
+			requestBody: null,
+			responseDescription: 'Returns all organizations the authenticated user belongs to.',
+			responseFields: { schema: OrgInfoApiSchema, stripRequired: true },
+			statuses: [
+				{ code: 200, description: 'Organizations returned' },
+				{ code: 401, description: 'Unauthorized — invalid or missing Bearer token' },
+			],
+			examplePath: '/cli/organization',
+		},
+		{
+			id: 'get-env-vars',
+			title: 'Get Environment Variables',
+			sectionTitle: 'Environment Variables',
+			method: 'GET',
+			path: '/cli/organization/{id}/env',
+			description: 'Retrieve environment variables and secrets for an organization.',
+			pathParams: [
+				{ name: 'id', type: 'string', description: 'Organization ID', required: true },
+			],
+			queryParams: [
+				{
+					name: 'mask',
+					type: 'boolean',
+					description: 'Mask secret values (default true)',
+					required: false,
+				},
+			],
+			requestBody: null,
+			responseDescription: 'Returns environment variables and secrets for the organization.',
+			responseFields: { schema: OrgEnvDataSchema },
+			statuses: [
+				{ code: 200, description: 'Environment variables returned' },
+				{ code: 401, description: 'Unauthorized — invalid or missing Bearer token' },
+				{ code: 404, description: 'Organization not found' },
+			],
+			examplePath: '/cli/organization/org_abc123/env',
+		},
+		{
+			id: 'update-env-vars',
+			title: 'Update Environment Variables',
+			sectionTitle: 'Environment Variables',
+			method: 'PUT',
+			path: '/cli/organization/{id}/env',
+			description:
+				'Update environment variables and secrets for an organization. Updates are merged with existing values.',
+			pathParams: [
+				{ name: 'id', type: 'string', description: 'Organization ID', required: true },
+			],
+			queryParams: [],
+			requestBody: {
+				description: 'Environment variables and secrets to set.',
+				fields: { schema: OrgEnvUpdateRequestSchema, omit: ['id'] },
+			},
+			responseDescription: 'Updates are merged with existing values. Returns 204 on success.',
+			statuses: [
+				{ code: 204, description: 'Environment variables updated' },
+				{ code: 401, description: 'Unauthorized — invalid or missing Bearer token' },
+				{ code: 404, description: 'Organization not found' },
+			],
+			examplePath: '/cli/organization/org_abc123/env',
+			exampleBody: { env: { MY_VAR: 'value' }, secrets: { API_KEY: 'sk_...' } },
+		},
+		{
+			id: 'delete-env-vars',
+			title: 'Delete Environment Variables',
+			sectionTitle: 'Environment Variables',
+			method: 'DELETE',
+			path: '/cli/organization/{id}/env',
+			description: 'Delete specific environment variables and secrets from an organization.',
+			pathParams: [
+				{ name: 'id', type: 'string', description: 'Organization ID', required: true },
+			],
+			queryParams: [],
+			requestBody: {
+				description: 'Keys to delete from environment variables and secrets.',
+				fields: { schema: OrgEnvDeleteRequestSchema, omit: ['id'] },
+			},
+			responseDescription: 'Returns 204 on success.',
+			statuses: [
+				{ code: 204, description: 'Environment variables deleted' },
+				{ code: 401, description: 'Unauthorized — invalid or missing Bearer token' },
+				{ code: 404, description: 'Organization not found' },
+			],
+			examplePath: '/cli/organization/org_abc123/env',
+			exampleBody: { env: ['MY_VAR'], secrets: ['OLD_KEY'] },
+		},
+		{
+			id: 'list-resources',
+			title: 'List All Resources',
+			sectionTitle: 'Resources',
+			method: 'GET',
+			path: '/resource',
+			description: 'List S3 buckets and databases across all regions.',
+			pathParams: [],
+			queryParams: [
+				{
+					name: 'type',
+					type: 'string',
+					description: "'all', 's3', or 'db' (default 'all')",
+					required: false,
+				},
+				{ name: 'name', type: 'string', description: 'Filter by name', required: false },
+				{
+					name: 'limit',
+					type: 'number',
+					description: 'Maximum results to return',
+					required: false,
+				},
+				{ name: 'offset', type: 'number', description: 'Pagination offset', required: false },
+				{
+					name: 'sort',
+					type: 'string',
+					description: "'name', 'created', or 'region'",
+					required: false,
+				},
+				{ name: 'direction', type: 'string', description: "'asc' or 'desc'", required: false },
+			],
+			requestBody: null,
+			responseDescription: 'Returns S3 buckets and databases across all regions.',
+			statuses: [
+				{ code: 200, description: 'Resources returned' },
+				{ code: 401, description: 'Unauthorized — invalid or missing Bearer token' },
+			],
+			examplePath: '/resource',
+		},
+	],
+};
+
+export default service;

package/src/services/org/types.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+/** Basic organization info returned in list endpoints */
+export const OrgInfoApiSchema = z.object({
+	id: z.string().describe('Organization ID'),
+	name: z.string().describe('Organization name'),
+});
+
+export type OrgInfo = z.infer<typeof OrgInfoApiSchema>;