@vertesia/common 1.6.0-dev.20260923.085325Z → 1.6.0-dev.20261008.064737Z

package/src/api-schemas/content.ts

@@ -338,6 +338,13 @@ const collectionPayloadFields = {
         .optional(),
     sensitivity: z.number().meta({ description: 'BLP sensitivity level for member documents' }).optional(),
     compartments: z.array(z.string()).meta({ description: 'Compartments for member documents' }).optional(),
+    shared_root: z
+        .boolean()
+        .meta({
+            description:
+                'Explicitly share this collection as a root of the project shared space (listable/readable by non-members via matching shared-content ABAC rules). This is the explicit API share flag — the sync never sets it.',
+        })
+        .optional(),
 };
 
 export const CreateCollectionPayloadSchema = z
@@ -492,6 +499,20 @@ export const CollectionSchema = z
             .array(z.string())
             .meta({ description: 'Compartments — propagated to member documents (union across collections)' })
             .optional(),
+        shared: z
+            .boolean()
+            .meta({
+                description:
+                    'Effective shared state: true iff the collection is a member of an effectively-shared parent collection (inherited; sync-managed). Combine with shared_root for full readability.',
+            })
+            .optional(),
+        shared_root: z
+            .boolean()
+            .meta({
+                description:
+                    'True iff the collection was explicitly shared via the API (a root of the project shared space). Never set by the sync.',
+            })
+            .optional(),
         shared_properties: z
             .array(z.string())
             .meta({
@@ -499,6 +520,10 @@ export const CollectionSchema = z
                     "List of property names from the collection's properties that should be shared with (injected into) member objects. These properties will be propagated to all members of this collection and merged as arrays.",
             })
             .optional(),
+        user_permissions: ContentObjectUserPermissionsSchema.meta({
+            description:
+                "Computed per-request permissions for the current user on this collection. Not stored — computed on the fly from the collection's security field (same semantics as a content object's user_permissions).",
+        }).optional(),
     })
     .meta({ id: 'Collection' });
 
@@ -548,6 +573,13 @@ export const CreateContentObjectPayloadSchema = z
                 description: 'Compartments — set directly or inherited from collections (union across collections).',
             })
             .optional(),
+        shared_root: z
+            .boolean()
+            .meta({
+                description:
+                    'Explicitly share this document as a root of the project shared space (readable by non-members via matching shared-content ABAC rules). This is the explicit API share flag — the sync never sets it.',
+            })
+            .optional(),
         inherited_properties: z
             .array(InheritedPropertyMetadataSchema)
             .meta({
@@ -648,6 +680,13 @@ export const UpdateContentObjectPayloadSchema = z
                 description: 'Compartments — set directly or inherited from collections (union across collections).',
             })
             .optional(),
+        shared_root: z
+            .boolean()
+            .meta({
+                description:
+                    'Explicitly share this document as a root of the project shared space (readable by non-members via matching shared-content ABAC rules). This is the explicit API share flag — the sync never sets it.',
+            })
+            .optional(),
         inherited_properties: z
             .array(InheritedPropertyMetadataSchema)
             .meta({
@@ -842,6 +881,20 @@ export const ContentObjectApiResponseSchema = z
                 description: 'Compartments — set directly or inherited from collections (union across collections).',
             })
             .optional(),
+        shared: z
+            .boolean()
+            .meta({
+                description:
+                    'Effective shared state: true iff the document is a member of an effectively-shared collection (inherited; sync-managed). Combine with shared_root for full readability.',
+            })
+            .optional(),
+        shared_root: z
+            .boolean()
+            .meta({
+                description:
+                    'True iff the document was explicitly shared via the API (a root of the project shared space). Never set by the sync.',
+            })
+            .optional(),
         inherited_properties: z.array(InheritedPropertyMetadataSchema).optional(),
     })
     .meta({ id: 'ContentObjectApiResponse' });
@@ -913,6 +966,8 @@ export const ContentObjectItemApiResponseSchema = z
         security: StringArrayMapSchema.optional(),
         sensitivity: z.number().nullable().optional(),
         compartments: z.array(z.string()).optional(),
+        shared: z.boolean().optional(),
+        shared_root: z.boolean().optional(),
         inherited_properties: z.array(InheritedPropertyMetadataSchema).optional(),
     })
     .meta({ id: 'ContentObjectItemApiResponse' });

package/src/api-schemas/cost-analytics.ts

@@ -47,8 +47,14 @@ export const CostAnalyticsQuerySchema = z
                 'service_tier',
                 'interaction',
                 'workflow',
+                'agent_run',
+                'workflow_run',
             ])
-            .meta({ description: 'Group results by this dimension' })
+            .meta({
+                description:
+                    'Group results by this dimension. `agent_run` groups by root agent run, including the calls of ' +
+                    'its sub-agents; `workflow_run` groups by Temporal workflow run, which separates each sub-agent.',
+            })
             .optional(),
         resolution: z.enum(['hour', 'day', 'week', 'month']).meta({ description: 'Time series resolution' }).optional(),
         model: z.string().meta({ description: 'Filter by model pattern' }).optional(),
@@ -60,6 +66,14 @@ export const CostAnalyticsQuerySchema = z
         workflow_run_id: z.string().meta({ description: 'Filter by Temporal workflow run ID' }).optional(),
         run_id: z.string().meta({ description: 'Filter by interaction execution run ID' }).optional(),
         agent_run_id: z.string().meta({ description: 'Filter by agent run ID' }).optional(),
+        agent_only: z
+            .boolean()
+            .meta({
+                description:
+                    'Restrict usage to agent runs and their attributed nested/background inference. ' +
+                    'Excludes standalone interactions and non-agent workflows. Defaults to false.',
+            })
+            .optional(),
         interaction_id: z
             .string()
             .meta({ description: 'Filter by interaction id: stored ObjectId or namespaced in-code id' })
@@ -141,11 +155,25 @@ export const ModelPricingSchema = z
         provider: z.string().optional(),
         provider_account_id: z.string().optional(),
         service_tier: z.string().meta({ description: 'Processing tier this price applies to' }).optional(),
+        min_prompt_tokens: z
+            .number()
+            .int()
+            .nonnegative()
+            .meta({
+                description:
+                    'When set, these prices apply to calls whose prompt (input, cached and cache-write tokens) is ' +
+                    'longer than this many tokens, in place of the prices without it.',
+            })
+            .optional(),
         input_price_per_m_tokens: z.number(),
         cached_input_price_per_m_tokens: z.number().optional(),
         cache_write_input_price_per_m_tokens: z.number().optional(),
         output_price_per_m_tokens: z.number(),
-        source: z.enum(['billing_export', 'model_pricing_daily', 'unavailable']),
+        source: z.enum(['billing_export', 'model_pricing_daily', 'run_time_estimate', 'unavailable']).meta({
+            description:
+                'Where the rates come from. `run_time_estimate` rates are the ones recorded on the calls when their ' +
+                'cost was estimated; the others come from the pricing catalog.',
+        }),
     })
     .meta({ id: 'ModelPricing' });
 
@@ -222,6 +250,18 @@ const PricingCoverageSchema = z.strictObject({
             calls: z.number(),
         }),
     ),
+    cost_by_source: z
+        .strictObject({
+            provider_billed: z.number().meta({ description: 'USD the provider reported billing for the calls.' }),
+            run_time_estimate: z.number().meta({
+                description: 'USD estimated from list prices when the calls ran, for calls with no billed amount.',
+            }),
+            price_table: z.number().meta({
+                description: 'USD computed from the pricing table, for calls with no cost recorded when they ran.',
+            }),
+        })
+        .optional()
+        .meta({ description: "How the total cost splits by where each call's cost came from." }),
 });
 
 export const ModelPriceComparisonResponseSchema = z

package/src/api-schemas/environment.ts

@@ -48,7 +48,6 @@ export const MediatorEnvConfigSchema = z
  */
 export const ExecutionEnvironmentSettingsSchema = z
     .object({
-        bucket_access_principal: z.string().optional(),
         default_headers: StringValueMapSchema.meta({
             description: 'Custom HTTP headers sent by OpenAI-compatible environments.',
         }).optional(),

package/src/api-schemas/group.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import type * as Wire from '../wire-types.generated.js';
 
 /**
  * Runtime API schemas for the IAM user-group endpoints.
@@ -162,4 +163,4 @@ export const UserGroupRefSchema = UserGroupSchema.pick({
  * The array components have no public alias of their own — `UserGroup[]` is what the client sees —
  * so this exists only for the gate in `./group.contract.test.ts` to assert that equivalence.
  */
-export type UserGroupArrayFromSchema = z.infer<typeof UserGroupArraySchema>;
+export type UserGroupArrayFromSchema = Wire.UserGroupArrayFromSchema;

package/src/api-schemas/index.ts

@@ -16,6 +16,7 @@ export * from './agent-runs.js';
 export * from './analytics.js';
 export * from './apikey.js';
 export * from './app-runtime.js';
+export { EventCategorySchema } from './audit-trail.js';
 export * from './bulk-operation.js';
 export * from './content.js';
 export * from './content-query.js';
@@ -34,6 +35,7 @@ export * from './process.js';
 export * from './process-agent-policy.js';
 export * from './quota.js';
 export * from './registry.js';
+export * from './run-budget.js';
 export * from './secrets.js';
 export { CreateContentObjectTypePayloadSchema, InteractionExecutionConfigurationSchema } from './store.js';
 export * from './view-execution.js';

package/src/api-schemas/inference-profile.ts

@@ -0,0 +1,151 @@
+import { ModelOptionsSchema } from '@llumiverse/common/schemas';
+import { z } from 'zod';
+import { AgentBudgetConfigurationSchema } from './agent-budget.js';
+
+export const InferenceProfileIdSchema = z
+    .string()
+    .regex(/^[a-fA-F0-9]{24}$/)
+    .meta({
+        id: 'InferenceProfileId',
+        description: 'MongoDB ObjectId of the inference profile.',
+    });
+
+export const InferenceProfileNameSchema = z
+    .string()
+    .min(1)
+    .max(80)
+    .regex(/\S/)
+    .meta({ id: 'InferenceProfileName', description: 'Editable display name, independent of the stable profile ID.' });
+
+export const InferenceProfileSchema = z
+    .strictObject({
+        name: InferenceProfileNameSchema.optional().meta({
+            description: 'Editable display name.',
+        }),
+        description: z.string().max(1000).optional(),
+        environment: z.string().regex(/^[a-fA-F0-9]{24}$/),
+        model: z.string().min(1).optional(),
+        model_options: ModelOptionsSchema.optional(),
+    })
+    .meta({
+        id: 'InferenceProfile',
+        description:
+            'A reusable environment, model and inference parameter preset. Credentials remain in the environment.',
+    });
+
+export const ProjectInferenceProfilesSchema = z
+    .strictObject({
+        default_profile: InferenceProfileIdSchema.optional(),
+        modality: z
+            .strictObject({
+                image: InferenceProfileIdSchema.optional(),
+                video: InferenceProfileIdSchema.optional(),
+            })
+            .optional(),
+        system: z
+            .strictObject({
+                content_type: InferenceProfileIdSchema.optional(),
+                intake: InferenceProfileIdSchema.optional(),
+                analysis: InferenceProfileIdSchema.optional(),
+                agent: InferenceProfileIdSchema.optional(),
+                non_applicable: InferenceProfileIdSchema.optional(),
+            })
+            .optional(),
+    })
+    .meta({
+        id: 'ProjectInferenceProfiles',
+        description:
+            'Project defaults reference profile MongoDB IDs. Profile definitions are managed through the inference profiles API.',
+    });
+
+export const InferenceProfileSnapshotSchema = z
+    .strictObject({
+        id: InferenceProfileIdSchema.optional(),
+        name: InferenceProfileNameSchema,
+        revision: z.string(),
+        source: z.enum(['request', 'binding', 'interaction', 'project']),
+        profile: InferenceProfileSchema,
+    })
+    .meta({
+        id: 'InferenceProfileSnapshot',
+        description:
+            'The selected profile and content revision at execution creation. Effective overrides are recorded in the execution config.',
+    });
+
+export const CreateInferenceProfilePayloadSchema = InferenceProfileSchema.extend({
+    name: InferenceProfileNameSchema,
+}).meta({
+    id: 'CreateInferenceProfilePayload',
+    description: 'Create a profile in the current project. The server assigns its MongoDB ID.',
+});
+
+export const UpdateInferenceProfilePayloadSchema = CreateInferenceProfilePayloadSchema.extend({}).meta({
+    id: 'UpdateInferenceProfilePayload',
+    description: 'Replace editable profile fields, preserving its ID and references.',
+});
+
+export const InferenceProfileRecordSchema = CreateInferenceProfilePayloadSchema.extend({
+    id: z.string().regex(/^[a-fA-F0-9]{24}$/),
+    project: z.string(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+}).meta({
+    id: 'InferenceProfileRecord',
+    description: 'A project-scoped inference profile stored as a MongoDB document.',
+});
+
+export const InferenceProfileRecordArraySchema = z
+    .array(InferenceProfileRecordSchema)
+    .meta({ id: 'InferenceProfileRecordArray' });
+
+export const UpdateInteractionConfigurationPayloadSchema = z
+    .strictObject({
+        inference_profile: InferenceProfileIdSchema.nullable(),
+        budget: AgentBudgetConfigurationSchema.nullable().optional().meta({
+            description:
+                'Project-scoped agent budget override. Null restores the code-defined or project default; omission preserves the saved budget.',
+        }),
+    })
+    .meta({ id: 'UpdateInteractionConfigurationPayload' });
+export const InteractionConfigurationRecordSchema = UpdateInteractionConfigurationPayloadSchema.extend({
+    id: z.string().regex(/^[a-fA-F0-9]{24}$/),
+    project: z.string(),
+    interaction: z.string(),
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+}).meta({ id: 'InteractionConfigurationRecord' });
+export const InteractionConfigurationResultSchema = z
+    .strictObject({
+        configuration: InteractionConfigurationRecordSchema.nullable(),
+    })
+    .meta({ id: 'InteractionConfigurationResult' });
+
+export const InferenceProfileUsageQuerySchema = z
+    .strictObject({
+        search: z.string().max(200).optional(),
+        kind: z.enum(['stored', 'system', 'app']).optional(),
+        offset: z.coerce.number().int().min(0).optional(),
+        limit: z.coerce.number().int().min(1).max(100).optional(),
+    })
+    .meta({ id: 'InferenceProfileUsageQuery' });
+
+export const InferenceProfileUsageEntrySchema = z
+    .strictObject({
+        id: z.string(),
+        name: z.string(),
+        kind: z.enum(['stored', 'system', 'app']),
+        version: z.number().optional(),
+        status: z.string().optional(),
+    })
+    .meta({ id: 'InferenceProfileUsageEntry' });
+
+export const InferenceProfileUsageSchema = z
+    .strictObject({
+        interactions: z.array(InferenceProfileUsageEntrySchema),
+        total: z.number().int().nonnegative(),
+        defaults: z.array(z.string()).meta({ description: 'Project default slots directly referencing this profile.' }),
+    })
+    .meta({
+        id: 'InferenceProfileUsage',
+        description: 'Persisted direct assignments; runtime overrides and inherited usage are not enumerated.',
+    });

package/src/api-schemas/interaction.ts

@@ -24,9 +24,10 @@ import { AgentToolApprovalModes } from '../store/agent-approval.js';
 import { LlmCallType } from '../workflow-analytics.js';
 import { ProjectRefSchema } from './apikey.js';
 import { ExecutionEnvironmentRefSchema } from './environment.js';
+import { InferenceProfileIdSchema, InferenceProfileSnapshotSchema } from './inference-profile.js';
 import { AccountRefSchema } from './invites.js';
 import { ProcessAgentExecutionPolicySchema } from './process-agent-policy.js';
-import { AgentCheckpointConfigurationSchema } from './project-configuration.js';
+import { AgentBudgetConfigurationSchema, AgentCheckpointConfigurationSchema } from './project-configuration.js';
 import { EditRevisionSchema, ExpectedEditRevisionSchema } from './schema-primitives.js';
 import { InteractionExecutionConfigurationSchema, RunDataStorageLevelSchema } from './store.js';
 
@@ -744,6 +745,8 @@ export const ResolvedRuntimeConfigSchema = z
         environment: ResolvedEnvironmentInfoSchema,
         model: z.string().optional(),
         model_source: ModelSourceSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
+        model_options: ModelOptionsSchema.optional(),
     })
     .meta({ id: 'ResolvedRuntimeConfig', description: 'Resolved runtime configuration for an interaction' });
 
@@ -803,6 +806,10 @@ export const AgentRunnerOptionsSchema = z
             description:
                 "Per-agent context checkpoint configuration. Field-wise it overrides the project's `configuration.agent.checkpoint`; a per-run `checkpoint_tokens` override still wins over both.",
         }).optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Per-agent token budget. Field-wise it overrides the project's `configuration.agent.budget`; the per-run `budget` wins over both.",
+        }).optional(),
     })
     .meta({
         id: 'AgentRunnerOptions',
@@ -883,6 +890,8 @@ export const RateLimitRequestPayloadSchema = z
     .strictObject({
         interaction: z.string(),
         environment_id: z.string().optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
+        inherit_model_config: z.boolean().optional(),
         model_id: z.string().optional(),
         workflow_run_id: z
             .string()
@@ -985,6 +994,7 @@ export const InteractionCreatePayloadSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1011,6 +1021,7 @@ export const InteractionSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1099,6 +1110,7 @@ export const InCodeInteractionSchema = z
         tags: z.array(z.string()).optional(),
         agent_runner_options: AgentRunnerOptionsSchema.optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         prompts: z.array(InCodePromptSchema),
         externalId: z.string().optional(),
         runtime: z
@@ -1232,6 +1244,7 @@ export const InteractionUpdatePayloadSchema = z
         environment: z.union([z.string(), ExecutionEnvironmentRefSchema]).optional(),
         model: z.string().optional(),
         model_options: ModelOptionsSchema.optional(),
+        inference_profile: InferenceProfileIdSchema.nullable().optional(),
         store_media_results: z.boolean().optional(),
         restriction: RunDataStorageLevelSchema.optional(),
         output_modality: ModalitiesSchema.meta({
@@ -1455,6 +1468,7 @@ export const ExecutionRunSchema: z.ZodType = z
         account: AccountRefSchema,
         project: ProjectRefSchema,
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1512,6 +1526,7 @@ export const InteractionExecutionResultSchema = z
         created_at: z.string().meta({ format: 'date-time' }),
         updated_at: z.string().meta({ format: 'date-time' }),
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1647,6 +1662,7 @@ export const ExecutionRunRefSchema = z
         account: AccountRefSchema,
         project: ProjectRefSchema,
         config: InteractionExecutionConfigurationSchema,
+        inference_profile: InferenceProfileSnapshotSchema.optional(),
         error: InteractionExecutionErrorSchema.optional(),
         source: RunSourceSchema,
         output_modality: ModalitiesSchema.meta({
@@ -1755,6 +1771,10 @@ export const ConversationStateSchema = z
                     'Project-configured checkpoint hard cap in tokens (cached from project.configuration.agent_checkpoint_tokens at conversation start). The workflow resolves the effective threshold from these, the per-run checkpoint_tokens override, and the model-based default.',
             })
             .optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Project-configured agent token budget (cached from project.configuration.agent.budget at conversation start). The workflow resolves the effective budget field-wise from this, the interaction's agent_runner_options.budget, and the per-run budget override.",
+        }).optional(),
         user_channels: z
             .array(UserChannelSchema)
             .meta({
@@ -2106,6 +2126,11 @@ export const AsyncInteractionExecutionPayloadSchema = z
     })
     .meta({ id: 'AsyncInteractionExecutionPayload' });
 
+export const AgentEvaluateRequestSchema = z.boolean().optional().meta({
+    description:
+        'Request LLM evaluation when the project evaluation policy is opt_in. Defaults to false. Cannot override disabled or opt out of always_on.',
+});
+
 export const ConversationEnrichmentFields = {
     title: z.string().min(1).meta({ description: 'Caller-provided conversation title.' }).optional(),
     topic: z
@@ -2136,6 +2161,7 @@ export const AsyncConversationExecutionPayloadSchema = z
                 'The interaction name and suffixed by an optional tag or version separated from the name using a @ character If no version/tag part is specified then the latest version is used. Example: ReviewContract, ReviewContract@draft, ReviewContract@1, ReviewContract@some-tag',
         }),
         ...ConversationEnrichmentFields,
+        evaluate: AgentEvaluateRequestSchema,
         app_version: z
             .string()
             .meta({
@@ -2268,6 +2294,10 @@ export const AsyncConversationExecutionPayloadSchema = z
             description:
                 "Structured per-run checkpoint override. Field-wise it takes precedence over the interaction's `agent_runner_options.checkpoint` and the project's `configuration.agent.checkpoint`. The legacy absolute `checkpoint_tokens` above still wins over everything when set.",
         }).optional(),
+        budget: AgentBudgetConfigurationSchema.meta({
+            description:
+                "Per-run token budget override. Field-wise it takes precedence over the interaction's `agent_runner_options.budget` and the project's `configuration.agent.budget`. Subagent workstreams receive the remaining budget of their parent here.",
+        }).optional(),
         strip_options: ConversationStripOptionsSchema.meta({
             description:
                 'Configuration for stripping large data (images, text) from conversation history to prevent JSON serialization issues and reduce storage bloat.',
@@ -2292,6 +2322,13 @@ export const AsyncConversationExecutionPayloadSchema = z
                     "Metadata inherited from parent workflow. Used to propagate context (e.g., apiKey, session info) to child workflows/workstreams. When a workstream is spawned, the parent's `data` is preserved here so that child tools can access it via metadata.parent_metadata.",
             })
             .optional(),
+        final_verification: z
+            .boolean()
+            .meta({
+                description:
+                    'When true, a non-interactive free-form run takes one extra turn after its answer to check that the task is complete. Off by default, and never applied to workstreams: their parent reviews the result and can message the workstream to continue.',
+            })
+            .optional(),
         non_blocking_subagents: z
             .boolean()
             .meta({
@@ -2423,6 +2460,8 @@ export const ResolveInteractionQuerySchema = z
     .strictObject({
         environment: z.string().optional(),
         model: z.string().optional(),
+        inference_profile: InferenceProfileIdSchema.optional(),
+        inherit_model_config: InteractionExecutionConfigurationSchema.shape.inherit_model_config,
         hasImage: z.boolean().optional(),
         hasVideo: z.boolean().optional(),
     })

package/src/api-schemas/invites.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 // From the values module, for the reason `./apikey.js` gives.
 import { TransientTokenType } from '../transient-tokens-values.js';
+import type * as Wire from '../wire-types.generated.js';
 import { AccountSchema } from './account.js';
 import { ProjectRefSchema, SystemRolesSchema } from './apikey.js';
 import { UserRefSchema } from './user.js';
@@ -116,12 +117,12 @@ export const AccountProjectsResponseSchema = z
     })
     .meta({ id: 'AccountProjectsResponse' });
 
-export type UserInviteTokenDataFromSchema = z.infer<typeof UserInviteTokenDataSchema>;
-export type UserInviteTokenFromSchema = z.infer<typeof UserInviteTokenSchema>;
-export type UserInviteTokenArrayFromSchema = z.infer<typeof UserInviteTokenArraySchema>;
-export type InviteUserRequestPayloadFromSchema = z.infer<typeof InviteUserRequestPayloadSchema>;
-export type InviteUserResponsePayloadFromSchema = z.infer<typeof InviteUserResponsePayloadSchema>;
-export type InviteAcceptanceResponseFromSchema = z.infer<typeof InviteAcceptanceResponseSchema>;
-export type InviteDeclineResponseFromSchema = z.infer<typeof InviteDeclineResponseSchema>;
-export type OnboardingProgressFromSchema = z.infer<typeof OnboardingProgressSchema>;
-export type AccountProjectsResponseFromSchema = z.infer<typeof AccountProjectsResponseSchema>;
+export type UserInviteTokenDataFromSchema = Wire.UserInviteTokenDataFromSchema;
+export type UserInviteTokenFromSchema = Wire.UserInviteTokenFromSchema;
+export type UserInviteTokenArrayFromSchema = Wire.UserInviteTokenArrayFromSchema;
+export type InviteUserRequestPayloadFromSchema = Wire.InviteUserRequestPayloadFromSchema;
+export type InviteUserResponsePayloadFromSchema = Wire.InviteUserResponsePayloadFromSchema;
+export type InviteAcceptanceResponseFromSchema = Wire.InviteAcceptanceResponseFromSchema;
+export type InviteDeclineResponseFromSchema = Wire.InviteDeclineResponseFromSchema;
+export type OnboardingProgressFromSchema = Wire.OnboardingProgressFromSchema;
+export type AccountProjectsResponseFromSchema = Wire.AccountProjectsResponseFromSchema;