@orchestration-ai/sdk 0.1.0

package/dist/cjs/types.gen.d.ts

@@ -0,0 +1,3653 @@
+export type ClientOptions = {
+    baseURL: 'https://api-dot-orchestration-ai-online-qa.ew.r.appspot.com' | (string & {});
+};
+/**
+ * User
+ */
+export type User = {
+    uid?: string;
+    display_name: string;
+    email: string;
+    photo_url?: string;
+    created_time?: string;
+};
+/**
+ * Workspace
+ */
+export type Workspace = {
+    id?: string;
+    workspace_name: string;
+    owner: User;
+    time_created?: string;
+    last_edited?: string;
+};
+/**
+ * NewWorkspace
+ *
+ * (tsType: Omit<Workspace, 'id' | 'time_created' | 'last_edited' | 'owner'>, schemaOptions: { title: 'NewWorkspace', exclude: [ 'id', 'time_created', 'last_edited', 'owner' ] })
+ */
+export type NewWorkspace = {
+    workspace_name: string;
+};
+/**
+ * WorkspaceWithRelations
+ *
+ * (tsType: WorkspaceWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type WorkspaceWithRelations = {
+    id?: string;
+    workspace_name: string;
+    owner: User;
+    time_created?: string;
+    last_edited?: string;
+};
+/**
+ * WorkspacePartialExcluding_id-owner-time_created-last_edited_
+ *
+ * (tsType: Omit<Partial<Workspace>, 'id' | 'owner' | 'time_created' | 'last_edited'>, schemaOptions: { partial: true, exclude: [ 'id', 'owner', 'time_created', 'last_edited' ] })
+ */
+export type WorkspacePartialExcludingIdOwnerTimeCreatedLastEdited = {
+    workspace_name?: string;
+};
+/**
+ * UserWithRelations
+ *
+ * (tsType: UserWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type UserWithRelations = {
+    uid?: string;
+    display_name: string;
+    email: string;
+    photo_url?: string;
+    created_time?: string;
+};
+/**
+ * Orchestration
+ */
+export type Orchestration = {
+    id?: string;
+    orchestration_name: string;
+    orchestration_description: string;
+    workspace: Workspace;
+};
+/**
+ * Agent
+ */
+export type Agent = {
+    id?: string;
+    agent_name: string;
+    agent_description: string;
+    orchestration?: Orchestration;
+};
+/**
+ * Application
+ */
+export type Application = {
+    id?: string;
+    access_key: string;
+    application_description_md: string;
+    application_name: string;
+    application_url: string;
+    last_edited: string;
+    owner?: User;
+    private: boolean;
+    time_created: string;
+    visible: boolean;
+};
+/**
+ * Setting
+ */
+export type Setting = {
+    id?: string;
+    agent?: Agent;
+    application?: Application;
+    boolean_value: boolean;
+    setting_description: string;
+    setting_name: string;
+    setting_type: string;
+    text_value: string;
+};
+/**
+ * NewSetting
+ *
+ * (tsType: Omit<Setting, 'id' | 'agent' | 'application'>, schemaOptions: { title: 'NewSetting', exclude: [ 'id', 'agent', 'application' ] })
+ */
+export type NewSetting = {
+    boolean_value: boolean;
+    setting_description: string;
+    setting_name: string;
+    setting_type: string;
+    text_value: string;
+};
+/**
+ * SettingWithRelations
+ *
+ * (tsType: SettingWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type SettingWithRelations = {
+    id?: string;
+    agent?: Agent;
+    application?: Application;
+    boolean_value: boolean;
+    setting_description: string;
+    setting_name: string;
+    setting_type: string;
+    text_value: string;
+};
+/**
+ * SettingPartialExcluding_id-agent-application_
+ *
+ * (tsType: Omit<Partial<Setting>, 'id' | 'agent' | 'application'>, schemaOptions: { partial: true, exclude: [ 'id', 'agent', 'application' ] })
+ */
+export type SettingPartialExcludingIdAgentApplication = {
+    boolean_value?: boolean;
+    setting_description?: string;
+    setting_name?: string;
+    setting_type?: string;
+    text_value?: string;
+};
+/**
+ * ServiceWithRelations
+ *
+ * (tsType: ServiceWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type ServiceWithRelations = {
+    id?: string;
+    application?: Application;
+    created_at: string;
+    doc_id: string;
+    owner?: User;
+    private: boolean;
+    service_description: string;
+    service_name: string;
+    unique_name: string;
+    visible?: boolean;
+};
+/**
+ * NewOrchestration
+ *
+ * (tsType: Omit<Orchestration, 'id' | 'workspace'>, schemaOptions: { title: 'NewOrchestration', exclude: [ 'id', 'workspace' ] })
+ */
+export type NewOrchestration = {
+    orchestration_name: string;
+    orchestration_description: string;
+};
+/**
+ * OrchestrationWithRelations
+ *
+ * (tsType: OrchestrationWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type OrchestrationWithRelations = {
+    id?: string;
+    orchestration_name: string;
+    orchestration_description: string;
+    workspace: Workspace;
+};
+/**
+ * OrchestrationPartialExcluding_id-workspace_
+ *
+ * (tsType: Omit<Partial<Orchestration>, 'id' | 'workspace'>, schemaOptions: { partial: true, exclude: [ 'id', 'workspace' ] })
+ */
+export type OrchestrationPartialExcludingIdWorkspace = {
+    orchestration_name?: string;
+    orchestration_description?: string;
+};
+/**
+ * LlmKeys
+ */
+export type LlmKeys = {
+    id?: string;
+    client_id: string;
+    client_secret: string;
+    owner?: User;
+    provider: 'Google' | 'OpenAI' | 'Anthropic';
+};
+/**
+ * LlmWithRelations
+ *
+ * (tsType: LlmWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type LlmWithRelations = {
+    id?: string;
+    llm_keys?: LlmKeys;
+    llm_name: string;
+    owner?: User;
+    provider_llm_id: string;
+};
+/**
+ * LlmKeysExcluding_client_secret_
+ *
+ * (tsType: Omit<LlmKeys, 'client_secret'>, schemaOptions: { exclude: [ 'client_secret' ] })
+ */
+export type LlmKeysExcludingClientSecret = {
+    id?: string;
+    client_id: string;
+    owner?: User;
+    provider: 'Google' | 'OpenAI' | 'Anthropic';
+};
+/**
+ * NewLlmKeys
+ *
+ * (tsType: Omit<LlmKeys, 'id' | 'owner'>, schemaOptions: { title: 'NewLlmKeys', exclude: [ 'id', 'owner' ] })
+ */
+export type NewLlmKeys = {
+    client_id: string;
+    client_secret: string;
+    provider: 'Google' | 'OpenAI' | 'Anthropic';
+};
+/**
+ * LlmKeysExcluding_client_secret_WithRelations
+ *
+ * (tsType: Omit<LlmKeysWithRelations, 'client_secret'>, schemaOptions: { includeRelations: true, exclude: [ 'client_secret' ] })
+ */
+export type LlmKeysExcludingClientSecretWithRelations = {
+    id?: string;
+    client_id: string;
+    owner?: User;
+    provider: 'Google' | 'OpenAI' | 'Anthropic';
+};
+/**
+ * LlmKeysPartialExcluding_id-owner_
+ *
+ * (tsType: Omit<Partial<LlmKeys>, 'id' | 'owner'>, schemaOptions: { partial: true, exclude: [ 'id', 'owner' ] })
+ */
+export type LlmKeysPartialExcludingIdOwner = {
+    client_id?: string;
+    client_secret?: string;
+    provider?: 'Google' | 'OpenAI' | 'Anthropic';
+};
+/**
+ * Link
+ */
+export type Link = {
+    id?: string;
+    agent?: Agent;
+    link_description: string;
+    link_name: string;
+    link_url: string;
+};
+/**
+ * NewLink
+ *
+ * (tsType: Omit<Link, 'id' | 'agent'>, schemaOptions: { title: 'NewLink', exclude: [ 'id', 'agent' ] })
+ */
+export type NewLink = {
+    link_description: string;
+    link_name: string;
+    link_url: string;
+};
+/**
+ * LinkWithRelations
+ *
+ * (tsType: LinkWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type LinkWithRelations = {
+    id?: string;
+    agent?: Agent;
+    link_description: string;
+    link_name: string;
+    link_url: string;
+};
+/**
+ * LinkPartialExcluding_id-agent_
+ *
+ * (tsType: Omit<Partial<Link>, 'id' | 'agent'>, schemaOptions: { partial: true, exclude: [ 'id', 'agent' ] })
+ */
+export type LinkPartialExcludingIdAgent = {
+    link_description?: string;
+    link_name?: string;
+    link_url?: string;
+};
+/**
+ * Llm
+ */
+export type Llm = {
+    id?: string;
+    llm_keys?: LlmKeys;
+    llm_name: string;
+    owner?: User;
+    provider_llm_id: string;
+};
+/**
+ * Service
+ */
+export type Service = {
+    id?: string;
+    application?: Application;
+    created_at: string;
+    doc_id: string;
+    owner?: User;
+    private: boolean;
+    service_description: string;
+    service_name: string;
+    unique_name: string;
+    visible?: boolean;
+};
+/**
+ * Layer
+ */
+export type Layer = {
+    id?: string;
+    agent?: Agent;
+    context_md?: string;
+    created_at: string;
+    layer_name: string;
+    llm?: Llm;
+    services?: Array<Service>;
+};
+/**
+ * LayerWithRelations
+ *
+ * (tsType: LayerWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type LayerWithRelations = {
+    id?: string;
+    agent?: Agent;
+    context_md?: string;
+    created_at: string;
+    layer_name: string;
+    llm?: Llm;
+    services?: Array<Service>;
+};
+/**
+ * Endpoint
+ */
+export type Endpoint = {
+    id?: string;
+    agent?: Agent;
+    description: string;
+    endpoint: string;
+};
+/**
+ * NewEndpoint
+ *
+ * (tsType: Omit<Endpoint, 'id' | 'agent'>, schemaOptions: { title: 'NewEndpoint', exclude: [ 'id', 'agent' ] })
+ */
+export type NewEndpoint = {
+    description: string;
+    endpoint: string;
+};
+/**
+ * EndpointWithRelations
+ *
+ * (tsType: EndpointWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type EndpointWithRelations = {
+    id?: string;
+    agent?: Agent;
+    description: string;
+    endpoint: string;
+};
+/**
+ * EndpointPartialExcluding_id-agent_
+ *
+ * (tsType: Omit<Partial<Endpoint>, 'id' | 'agent'>, schemaOptions: { partial: true, exclude: [ 'id', 'agent' ] })
+ */
+export type EndpointPartialExcludingIdAgent = {
+    description?: string;
+    endpoint?: string;
+};
+/**
+ * DayPassTransactionWithRelations
+ *
+ * (tsType: DayPassTransactionWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type DayPassTransactionWithRelations = {
+    id?: string;
+    balance: number;
+    charge_reason?: string;
+    customer_email: string;
+    transaction_date: string;
+};
+/**
+ * NewApplication
+ *
+ * (tsType: Omit<Application, 'id' | 'owner' | 'time_created' | 'last_edited'>, schemaOptions: { title: 'NewApplication', exclude: [ 'id', 'owner', 'time_created', 'last_edited' ] })
+ */
+export type NewApplication = {
+    access_key: string;
+    application_description_md: string;
+    application_name: string;
+    application_url: string;
+    private: boolean;
+    visible: boolean;
+};
+/**
+ * ApplicationWithRelations
+ *
+ * (tsType: ApplicationWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type ApplicationWithRelations = {
+    id?: string;
+    access_key: string;
+    application_description_md: string;
+    application_name: string;
+    application_url: string;
+    last_edited: string;
+    owner?: User;
+    private: boolean;
+    time_created: string;
+    visible: boolean;
+};
+/**
+ * ApplicationPartialExcluding_id-owner-time_created-last_edited_
+ *
+ * (tsType: Omit<Partial<Application>, 'id' | 'owner' | 'time_created' | 'last_edited'>, schemaOptions: { partial: true, exclude: [ 'id', 'owner', 'time_created', 'last_edited' ] })
+ */
+export type ApplicationPartialExcludingIdOwnerTimeCreatedLastEdited = {
+    access_key?: string;
+    application_description_md?: string;
+    application_name?: string;
+    application_url?: string;
+    private?: boolean;
+    visible?: boolean;
+};
+/**
+ * ApplicationExcluding_access_key_WithRelations
+ *
+ * (tsType: Omit<ApplicationWithRelations, 'access_key'>, schemaOptions: { includeRelations: true, exclude: [ 'access_key' ] })
+ */
+export type ApplicationExcludingAccessKeyWithRelations = {
+    id?: string;
+    application_description_md: string;
+    application_name: string;
+    application_url: string;
+    last_edited: string;
+    owner?: User;
+    private: boolean;
+    time_created: string;
+    visible: boolean;
+};
+/**
+ * NewAgent
+ *
+ * (tsType: Omit<Agent, 'id' | 'orchestration'>, schemaOptions: { title: 'NewAgent', exclude: [ 'id', 'orchestration' ] })
+ */
+export type NewAgent = {
+    agent_name: string;
+    agent_description: string;
+};
+/**
+ * AgentWithRelations
+ *
+ * (tsType: AgentWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type AgentWithRelations = {
+    id?: string;
+    agent_name: string;
+    agent_description: string;
+    orchestration?: Orchestration;
+};
+/**
+ * AgentPartialExcluding_id-orchestration_
+ *
+ * (tsType: Omit<Partial<Agent>, 'id' | 'orchestration'>, schemaOptions: { partial: true, exclude: [ 'id', 'orchestration' ] })
+ */
+export type AgentPartialExcludingIdOrchestration = {
+    agent_name?: string;
+    agent_description?: string;
+};
+/**
+ * Access
+ */
+export type Access = {
+    id?: string;
+    resource_id?: string;
+    on_behalf_of?: User;
+    principal_id: string;
+    principal_name: string;
+    principal_email: string;
+    role: string;
+};
+/**
+ * NewAccess
+ *
+ * (tsType: Omit<Access, 'id' | 'on_behalf_of'>, schemaOptions: { title: 'NewAccess', exclude: [ 'id', 'on_behalf_of' ] })
+ */
+export type NewAccess = {
+    resource_id?: string;
+    principal_id: string;
+    principal_name: string;
+    principal_email: string;
+    role: string;
+};
+/**
+ * AccessWithRelations
+ *
+ * (tsType: AccessWithRelations, schemaOptions: { includeRelations: true })
+ */
+export type AccessWithRelations = {
+    id?: string;
+    resource_id?: string;
+    on_behalf_of?: User;
+    principal_id: string;
+    principal_name: string;
+    principal_email: string;
+    role: string;
+};
+/**
+ * PingResponse
+ */
+export type PingResponse = {
+    greeting?: string;
+    date?: string;
+    url?: string;
+    headers?: {
+        'Content-Type'?: string;
+        [key: string]: unknown;
+    };
+};
+export type AccessFindByPrincipalData = {
+    body?: never;
+    path?: never;
+    query?: {
+        resourceId?: string;
+        limit?: number;
+        offset?: number;
+    };
+    url: '/access/principal';
+};
+export type AccessFindByPrincipalErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AccessFindByPrincipalError = AccessFindByPrincipalErrors[keyof AccessFindByPrincipalErrors];
+export type AccessFindByPrincipalResponses = {
+    /**
+     * Array of Access model instances for principal with pagination
+     */
+    200: {
+        access?: Array<AccessWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type AccessFindByPrincipalResponse = AccessFindByPrincipalResponses[keyof AccessFindByPrincipalResponses];
+export type AccessDeleteByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/access/{id}';
+};
+export type AccessDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Access not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Cannot remove owner access
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AccessDeleteByIdError = AccessDeleteByIdErrors[keyof AccessDeleteByIdErrors];
+export type AccessDeleteByIdResponses = {
+    /**
+     * Access DELETE success
+     */
+    204: unknown;
+};
+export type AccessFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/access/{id}';
+};
+export type AccessFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Access not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AccessFindByIdError = AccessFindByIdErrors[keyof AccessFindByIdErrors];
+export type AccessFindByIdResponses = {
+    /**
+     * Access model instance
+     */
+    200: AccessWithRelations;
+};
+export type AccessFindByIdResponse = AccessFindByIdResponses[keyof AccessFindByIdResponses];
+export type AccessFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        resourceId?: string;
+        limit?: number;
+        offset?: number;
+    };
+    url: '/access';
+};
+export type AccessFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AccessFindError = AccessFindErrors[keyof AccessFindErrors];
+export type AccessFindResponses = {
+    /**
+     * Array of Access model instances with pagination
+     */
+    200: {
+        access?: Array<AccessWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type AccessFindResponse = AccessFindResponses[keyof AccessFindResponses];
+export type AccessCreateData = {
+    body?: NewAccess;
+    path?: never;
+    query?: never;
+    url: '/access';
+};
+export type AccessCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AccessCreateError = AccessCreateErrors[keyof AccessCreateErrors];
+export type AccessCreateResponses = {
+    /**
+     * Access model instance
+     */
+    200: Access;
+};
+export type AccessCreateResponse = AccessCreateResponses[keyof AccessCreateResponses];
+export type ApplicationFindVisibleByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/applications/visible/{id}';
+};
+export type ApplicationFindVisibleByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Application not found or not visible
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationFindVisibleByIdError = ApplicationFindVisibleByIdErrors[keyof ApplicationFindVisibleByIdErrors];
+export type ApplicationFindVisibleByIdResponses = {
+    /**
+     * Visible Application model instance
+     */
+    200: ApplicationExcludingAccessKeyWithRelations;
+};
+export type ApplicationFindVisibleByIdResponse = ApplicationFindVisibleByIdResponses[keyof ApplicationFindVisibleByIdResponses];
+export type ApplicationFindVisibleData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/applications/visible';
+};
+export type ApplicationFindVisibleErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationFindVisibleError = ApplicationFindVisibleErrors[keyof ApplicationFindVisibleErrors];
+export type ApplicationFindVisibleResponses = {
+    /**
+     * Array of visible Application model instances with pagination
+     */
+    200: {
+        applications?: Array<ApplicationExcludingAccessKeyWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type ApplicationFindVisibleResponse = ApplicationFindVisibleResponses[keyof ApplicationFindVisibleResponses];
+export type ApplicationDeleteByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/applications/{id}';
+};
+export type ApplicationDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Application not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationDeleteByIdError = ApplicationDeleteByIdErrors[keyof ApplicationDeleteByIdErrors];
+export type ApplicationDeleteByIdResponses = {
+    /**
+     * Application DELETE success
+     */
+    204: unknown;
+};
+export type ApplicationFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/applications/{id}';
+};
+export type ApplicationFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Application not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationFindByIdError = ApplicationFindByIdErrors[keyof ApplicationFindByIdErrors];
+export type ApplicationFindByIdResponses = {
+    /**
+     * Application model instance
+     */
+    200: ApplicationWithRelations;
+};
+export type ApplicationFindByIdResponse = ApplicationFindByIdResponses[keyof ApplicationFindByIdResponses];
+export type ApplicationUpdateByIdData = {
+    body?: ApplicationPartialExcludingIdOwnerTimeCreatedLastEdited;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/applications/{id}';
+};
+export type ApplicationUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Application not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationUpdateByIdError = ApplicationUpdateByIdErrors[keyof ApplicationUpdateByIdErrors];
+export type ApplicationUpdateByIdResponses = {
+    /**
+     * Application PATCH success
+     */
+    204: unknown;
+};
+export type ApplicationFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/applications';
+};
+export type ApplicationFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationFindError = ApplicationFindErrors[keyof ApplicationFindErrors];
+export type ApplicationFindResponses = {
+    /**
+     * Array of Application model instances with pagination
+     */
+    200: {
+        applications?: Array<ApplicationWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type ApplicationFindResponse = ApplicationFindResponses[keyof ApplicationFindResponses];
+export type ApplicationCreateData = {
+    body?: NewApplication;
+    path?: never;
+    query?: never;
+    url: '/applications';
+};
+export type ApplicationCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ApplicationCreateError = ApplicationCreateErrors[keyof ApplicationCreateErrors];
+export type ApplicationCreateResponses = {
+    /**
+     * Application model instance
+     */
+    200: Application;
+};
+export type ApplicationCreateResponse = ApplicationCreateResponses[keyof ApplicationCreateResponses];
+export type AuthMintTokenData = {
+    body?: never;
+    path: {
+        uid: string;
+    };
+    query?: never;
+    url: '/auth/mint-token/{uid}';
+};
+export type AuthMintTokenErrors = {
+    /**
+     * Unprocessable Entity - UID not allowed for token minting
+     */
+    422: string;
+};
+export type AuthMintTokenError = AuthMintTokenErrors[keyof AuthMintTokenErrors];
+export type AuthMintTokenResponses = {
+    /**
+     * Mint JWT token for testing. For internal testing only.
+     */
+    200: string;
+};
+export type AuthMintTokenResponse = AuthMintTokenResponses[keyof AuthMintTokenResponses];
+export type DayPassTransactionFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/day-pass-transactions';
+};
+export type DayPassTransactionFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type DayPassTransactionFindError = DayPassTransactionFindErrors[keyof DayPassTransactionFindErrors];
+export type DayPassTransactionFindResponses = {
+    /**
+     * Array of DayPassTransaction model instances with pagination
+     */
+    200: {
+        dayPassTransactions?: Array<DayPassTransactionWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type DayPassTransactionFindResponse = DayPassTransactionFindResponses[keyof DayPassTransactionFindResponses];
+export type LlmKeysFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/llm-keys/{id}';
+};
+export type LlmKeysFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - LlmKeys not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmKeysFindByIdError = LlmKeysFindByIdErrors[keyof LlmKeysFindByIdErrors];
+export type LlmKeysFindByIdResponses = {
+    /**
+     * LlmKeys model instance
+     */
+    200: LlmKeysExcludingClientSecretWithRelations;
+};
+export type LlmKeysFindByIdResponse = LlmKeysFindByIdResponses[keyof LlmKeysFindByIdResponses];
+export type LlmKeysUpdateByIdData = {
+    body?: LlmKeysPartialExcludingIdOwner;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/llm-keys/{id}';
+};
+export type LlmKeysUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - LlmKeys not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmKeysUpdateByIdError = LlmKeysUpdateByIdErrors[keyof LlmKeysUpdateByIdErrors];
+export type LlmKeysUpdateByIdResponses = {
+    /**
+     * LlmKeys PATCH success
+     */
+    204: unknown;
+};
+export type LlmKeysFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/llm-keys';
+};
+export type LlmKeysFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmKeysFindError = LlmKeysFindErrors[keyof LlmKeysFindErrors];
+export type LlmKeysFindResponses = {
+    /**
+     * Array of LlmKeys model instances with pagination
+     */
+    200: {
+        llmKeys?: Array<LlmKeysExcludingClientSecretWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type LlmKeysFindResponse = LlmKeysFindResponses[keyof LlmKeysFindResponses];
+export type LlmKeysCreateData = {
+    body?: NewLlmKeys;
+    path?: never;
+    query?: never;
+    url: '/llm-keys';
+};
+export type LlmKeysCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmKeysCreateError = LlmKeysCreateErrors[keyof LlmKeysCreateErrors];
+export type LlmKeysCreateResponses = {
+    /**
+     * LlmKeys model instance
+     */
+    200: LlmKeysExcludingClientSecret;
+};
+export type LlmKeysCreateResponse = LlmKeysCreateResponses[keyof LlmKeysCreateResponses];
+export type LlmFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/llms/{id}';
+};
+export type LlmFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Llm not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmFindByIdError = LlmFindByIdErrors[keyof LlmFindByIdErrors];
+export type LlmFindByIdResponses = {
+    /**
+     * Llm model instance
+     */
+    200: LlmWithRelations;
+};
+export type LlmFindByIdResponse = LlmFindByIdResponses[keyof LlmFindByIdResponses];
+export type LlmFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/llms';
+};
+export type LlmFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LlmFindError = LlmFindErrors[keyof LlmFindErrors];
+export type LlmFindResponses = {
+    /**
+     * Array of Llm model instances with pagination
+     */
+    200: {
+        llms?: Array<LlmWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type LlmFindResponse = LlmFindResponses[keyof LlmFindResponses];
+export type OAuthConsentData = {
+    body?: {
+        id_token: string;
+        client_id: string;
+        redirect_uri: string;
+        scope: string;
+        state: string;
+        granted: boolean;
+    };
+    path?: never;
+    query?: never;
+    url: '/oauth/authorize/consent';
+};
+export type OAuthConsentErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Invalid token
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthConsentError = OAuthConsentErrors[keyof OAuthConsentErrors];
+export type OAuthConsentResponses = {
+    /**
+     * Consent processed
+     */
+    200: {
+        redirect_url?: string;
+    };
+};
+export type OAuthConsentResponse = OAuthConsentResponses[keyof OAuthConsentResponses];
+export type OAuthForgotPasswordData = {
+    body?: {
+        email: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/oauth/authorize/forgot-password';
+};
+export type OAuthForgotPasswordErrors = {
+    /**
+     * Failed to send reset email
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthForgotPasswordError = OAuthForgotPasswordErrors[keyof OAuthForgotPasswordErrors];
+export type OAuthForgotPasswordResponses = {
+    /**
+     * Password reset email sent
+     */
+    200: {
+        message?: string;
+    };
+};
+export type OAuthForgotPasswordResponse = OAuthForgotPasswordResponses[keyof OAuthForgotPasswordResponses];
+export type OAuthLoginData = {
+    body?: {
+        email: string;
+        password: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/oauth/authorize/login';
+};
+export type OAuthLoginErrors = {
+    /**
+     * Invalid credentials
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthLoginError = OAuthLoginErrors[keyof OAuthLoginErrors];
+export type OAuthLoginResponses = {
+    /**
+     * Login successful
+     */
+    200: {
+        uid?: string;
+        email?: string;
+        display_name?: string;
+        id_token?: string;
+    };
+};
+export type OAuthLoginResponse = OAuthLoginResponses[keyof OAuthLoginResponses];
+export type OAuthSignupData = {
+    body?: {
+        email: string;
+        password: string;
+        display_name: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/oauth/authorize/signup';
+};
+export type OAuthSignupErrors = {
+    /**
+     * Signup failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthSignupError = OAuthSignupErrors[keyof OAuthSignupErrors];
+export type OAuthSignupResponses = {
+    /**
+     * Signup successful
+     */
+    200: {
+        uid?: string;
+        email?: string;
+        display_name?: string;
+        id_token?: string;
+    };
+};
+export type OAuthSignupResponse = OAuthSignupResponses[keyof OAuthSignupResponses];
+export type OAuthAuthorizeData = {
+    body?: never;
+    path?: never;
+    query?: {
+        response_type?: string;
+        client_id?: string;
+        redirect_uri?: string;
+        scope?: string;
+        state?: string;
+    };
+    url: '/oauth/authorize';
+};
+export type OAuthAuthorizeErrors = {
+    /**
+     * Invalid request parameters
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthAuthorizeError = OAuthAuthorizeErrors[keyof OAuthAuthorizeErrors];
+export type OAuthTokenData = {
+    body?: {
+        grant_type: string;
+        code?: string;
+        refresh_token?: string;
+        client_id: string;
+        client_secret: string;
+        redirect_uri?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/oauth/token';
+};
+export type OAuthTokenErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Invalid client credentials
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OAuthTokenError = OAuthTokenErrors[keyof OAuthTokenErrors];
+export type OAuthTokenResponses = {
+    /**
+     * Token response
+     */
+    200: {
+        access_token?: string;
+        token_type?: string;
+        expires_in?: number;
+        refresh_token?: string;
+        scope?: string;
+    };
+};
+export type OAuthTokenResponse = OAuthTokenResponses[keyof OAuthTokenResponses];
+export type PingPingData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/ping';
+};
+export type PingPingResponses = {
+    /**
+     * Ping Response
+     */
+    200: PingResponse;
+};
+export type PingPingResponse = PingPingResponses[keyof PingPingResponses];
+export type ServiceFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/services/{id}';
+};
+export type ServiceFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Service not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ServiceFindByIdError = ServiceFindByIdErrors[keyof ServiceFindByIdErrors];
+export type ServiceFindByIdResponses = {
+    /**
+     * Service model instance
+     */
+    200: ServiceWithRelations;
+};
+export type ServiceFindByIdResponse = ServiceFindByIdResponses[keyof ServiceFindByIdResponses];
+export type ServiceFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/services';
+};
+export type ServiceFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type ServiceFindError = ServiceFindErrors[keyof ServiceFindErrors];
+export type ServiceFindResponses = {
+    /**
+     * Array of Service model instances with pagination
+     */
+    200: {
+        services?: Array<ServiceWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type ServiceFindResponse = ServiceFindResponses[keyof ServiceFindResponses];
+export type UserGetCurrentUserData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/users/me';
+};
+export type UserGetCurrentUserResponses = {
+    /**
+     * Current authenticated user
+     */
+    200: UserWithRelations;
+};
+export type UserGetCurrentUserResponse = UserGetCurrentUserResponses[keyof UserGetCurrentUserResponses];
+export type EndpointDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/endpoints/{id}';
+};
+export type EndpointDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Endpoint not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type EndpointDeleteByIdError = EndpointDeleteByIdErrors[keyof EndpointDeleteByIdErrors];
+export type EndpointDeleteByIdResponses = {
+    /**
+     * Endpoint DELETE success
+     */
+    204: unknown;
+};
+export type EndpointFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/endpoints/{id}';
+};
+export type EndpointFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Endpoint not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type EndpointFindByIdError = EndpointFindByIdErrors[keyof EndpointFindByIdErrors];
+export type EndpointFindByIdResponses = {
+    /**
+     * Endpoint model instance
+     */
+    200: EndpointWithRelations;
+};
+export type EndpointFindByIdResponse = EndpointFindByIdResponses[keyof EndpointFindByIdResponses];
+export type EndpointUpdateByIdData = {
+    body?: EndpointPartialExcludingIdAgent;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/endpoints/{id}';
+};
+export type EndpointUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Endpoint not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type EndpointUpdateByIdError = EndpointUpdateByIdErrors[keyof EndpointUpdateByIdErrors];
+export type EndpointUpdateByIdResponses = {
+    /**
+     * Endpoint PATCH success
+     */
+    204: unknown;
+};
+export type EndpointFindByAgentData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/endpoints';
+};
+export type EndpointFindByAgentErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type EndpointFindByAgentError = EndpointFindByAgentErrors[keyof EndpointFindByAgentErrors];
+export type EndpointFindByAgentResponses = {
+    /**
+     * Array of Endpoint model instances with pagination
+     */
+    200: {
+        endpoints?: Array<EndpointWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type EndpointFindByAgentResponse = EndpointFindByAgentResponses[keyof EndpointFindByAgentResponses];
+export type EndpointCreateData = {
+    body?: NewEndpoint;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/endpoints';
+};
+export type EndpointCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type EndpointCreateError = EndpointCreateErrors[keyof EndpointCreateErrors];
+export type EndpointCreateResponses = {
+    /**
+     * Endpoint model instance
+     */
+    200: Endpoint;
+};
+export type EndpointCreateResponse = EndpointCreateResponses[keyof EndpointCreateResponses];
+export type LayerDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/layers/{id}';
+};
+export type LayerDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Layer not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LayerDeleteByIdError = LayerDeleteByIdErrors[keyof LayerDeleteByIdErrors];
+export type LayerDeleteByIdResponses = {
+    /**
+     * Layer DELETE success
+     */
+    204: unknown;
+};
+export type LayerFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/layers/{id}';
+};
+export type LayerFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Layer not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LayerFindByIdError = LayerFindByIdErrors[keyof LayerFindByIdErrors];
+export type LayerFindByIdResponses = {
+    /**
+     * Layer model instance
+     */
+    200: LayerWithRelations;
+};
+export type LayerFindByIdResponse = LayerFindByIdResponses[keyof LayerFindByIdResponses];
+export type LayerUpdateByIdData = {
+    body?: {
+        context_md?: string;
+        layer_name?: string;
+        llm?: {
+            id?: string;
+        };
+        services?: Array<{
+            id?: string;
+        }>;
+    };
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/layers/{id}';
+};
+export type LayerUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Layer not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LayerUpdateByIdError = LayerUpdateByIdErrors[keyof LayerUpdateByIdErrors];
+export type LayerUpdateByIdResponses = {
+    /**
+     * Layer PATCH success
+     */
+    204: unknown;
+};
+export type LayerFindByAgentData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/layers';
+};
+export type LayerFindByAgentErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LayerFindByAgentError = LayerFindByAgentErrors[keyof LayerFindByAgentErrors];
+export type LayerFindByAgentResponses = {
+    /**
+     * Array of Layer model instances with pagination
+     */
+    200: {
+        layers?: Array<LayerWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type LayerFindByAgentResponse = LayerFindByAgentResponses[keyof LayerFindByAgentResponses];
+export type LayerCreateData = {
+    body?: {
+        context_md?: string;
+        layer_name: string;
+        llm?: {
+            id?: string;
+        };
+        services?: Array<{
+            id?: string;
+        }>;
+    };
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/layers';
+};
+export type LayerCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LayerCreateError = LayerCreateErrors[keyof LayerCreateErrors];
+export type LayerCreateResponses = {
+    /**
+     * Layer model instance
+     */
+    200: Layer;
+};
+export type LayerCreateResponse = LayerCreateResponses[keyof LayerCreateResponses];
+export type LinkDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/links/{id}';
+};
+export type LinkDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Link not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LinkDeleteByIdError = LinkDeleteByIdErrors[keyof LinkDeleteByIdErrors];
+export type LinkDeleteByIdResponses = {
+    /**
+     * Link DELETE success
+     */
+    204: unknown;
+};
+export type LinkFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/links/{id}';
+};
+export type LinkFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Link not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LinkFindByIdError = LinkFindByIdErrors[keyof LinkFindByIdErrors];
+export type LinkFindByIdResponses = {
+    /**
+     * Link model instance
+     */
+    200: LinkWithRelations;
+};
+export type LinkFindByIdResponse = LinkFindByIdResponses[keyof LinkFindByIdResponses];
+export type LinkUpdateByIdData = {
+    body?: LinkPartialExcludingIdAgent;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/links/{id}';
+};
+export type LinkUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Link not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LinkUpdateByIdError = LinkUpdateByIdErrors[keyof LinkUpdateByIdErrors];
+export type LinkUpdateByIdResponses = {
+    /**
+     * Link PATCH success
+     */
+    204: unknown;
+};
+export type LinkFindByAgentData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/links';
+};
+export type LinkFindByAgentErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LinkFindByAgentError = LinkFindByAgentErrors[keyof LinkFindByAgentErrors];
+export type LinkFindByAgentResponses = {
+    /**
+     * Array of Link model instances with pagination
+     */
+    200: {
+        links?: Array<LinkWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type LinkFindByAgentResponse = LinkFindByAgentResponses[keyof LinkFindByAgentResponses];
+export type LinkCreateData = {
+    body?: NewLink;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/links';
+};
+export type LinkCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type LinkCreateError = LinkCreateErrors[keyof LinkCreateErrors];
+export type LinkCreateResponses = {
+    /**
+     * Link model instance
+     */
+    200: Link;
+};
+export type LinkCreateResponse = LinkCreateResponses[keyof LinkCreateResponses];
+export type SettingDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/settings/{id}';
+};
+export type SettingDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Setting not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type SettingDeleteByIdError = SettingDeleteByIdErrors[keyof SettingDeleteByIdErrors];
+export type SettingDeleteByIdResponses = {
+    /**
+     * Setting DELETE success
+     */
+    204: unknown;
+};
+export type SettingFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/settings/{id}';
+};
+export type SettingFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Setting not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type SettingFindByIdError = SettingFindByIdErrors[keyof SettingFindByIdErrors];
+export type SettingFindByIdResponses = {
+    /**
+     * Setting model instance
+     */
+    200: SettingWithRelations;
+};
+export type SettingFindByIdResponse = SettingFindByIdResponses[keyof SettingFindByIdResponses];
+export type SettingUpdateByIdData = {
+    body?: SettingPartialExcludingIdAgentApplication;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/settings/{id}';
+};
+export type SettingUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Setting not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type SettingUpdateByIdError = SettingUpdateByIdErrors[keyof SettingUpdateByIdErrors];
+export type SettingUpdateByIdResponses = {
+    /**
+     * Setting PATCH success
+     */
+    204: unknown;
+};
+export type SettingFindByAgentData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/settings';
+};
+export type SettingFindByAgentErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type SettingFindByAgentError = SettingFindByAgentErrors[keyof SettingFindByAgentErrors];
+export type SettingFindByAgentResponses = {
+    /**
+     * Array of Setting model instances with pagination
+     */
+    200: {
+        settings?: Array<SettingWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type SettingFindByAgentResponse = SettingFindByAgentResponses[keyof SettingFindByAgentResponses];
+export type SettingCreateData = {
+    body?: NewSetting;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        agentId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{agentId}/settings';
+};
+export type SettingCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type SettingCreateError = SettingCreateErrors[keyof SettingCreateErrors];
+export type SettingCreateResponses = {
+    /**
+     * Setting model instance
+     */
+    200: Setting;
+};
+export type SettingCreateResponse = SettingCreateResponses[keyof SettingCreateResponses];
+export type AgentDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{id}';
+};
+export type AgentDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Agent not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AgentDeleteByIdError = AgentDeleteByIdErrors[keyof AgentDeleteByIdErrors];
+export type AgentDeleteByIdResponses = {
+    /**
+     * Agent DELETE success
+     */
+    204: unknown;
+};
+export type AgentFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{id}';
+};
+export type AgentFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Agent not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AgentFindByIdError = AgentFindByIdErrors[keyof AgentFindByIdErrors];
+export type AgentFindByIdResponses = {
+    /**
+     * Agent model instance
+     */
+    200: AgentWithRelations;
+};
+export type AgentFindByIdResponse = AgentFindByIdResponses[keyof AgentFindByIdResponses];
+export type AgentUpdateByIdData = {
+    body?: AgentPartialExcludingIdOrchestration;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents/{id}';
+};
+export type AgentUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Agent not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AgentUpdateByIdError = AgentUpdateByIdErrors[keyof AgentUpdateByIdErrors];
+export type AgentUpdateByIdResponses = {
+    /**
+     * Agent PATCH success
+     */
+    204: unknown;
+};
+export type AgentFindByOrchestrationData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents';
+};
+export type AgentFindByOrchestrationErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AgentFindByOrchestrationError = AgentFindByOrchestrationErrors[keyof AgentFindByOrchestrationErrors];
+export type AgentFindByOrchestrationResponses = {
+    /**
+     * Array of Agent model instances with pagination
+     */
+    200: {
+        agents?: Array<AgentWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type AgentFindByOrchestrationResponse = AgentFindByOrchestrationResponses[keyof AgentFindByOrchestrationResponses];
+export type AgentCreateData = {
+    body?: NewAgent;
+    path: {
+        workspaceId: string;
+        orchestrationId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{orchestrationId}/agents';
+};
+export type AgentCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type AgentCreateError = AgentCreateErrors[keyof AgentCreateErrors];
+export type AgentCreateResponses = {
+    /**
+     * Agent model instance
+     */
+    200: Agent;
+};
+export type AgentCreateResponse = AgentCreateResponses[keyof AgentCreateResponses];
+export type OrchestrationDeleteByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{id}';
+};
+export type OrchestrationDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Orchestration not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OrchestrationDeleteByIdError = OrchestrationDeleteByIdErrors[keyof OrchestrationDeleteByIdErrors];
+export type OrchestrationDeleteByIdResponses = {
+    /**
+     * Orchestration DELETE success
+     */
+    204: unknown;
+};
+export type OrchestrationFindByIdData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{id}';
+};
+export type OrchestrationFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Orchestration not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OrchestrationFindByIdError = OrchestrationFindByIdErrors[keyof OrchestrationFindByIdErrors];
+export type OrchestrationFindByIdResponses = {
+    /**
+     * Orchestration model instance
+     */
+    200: OrchestrationWithRelations;
+};
+export type OrchestrationFindByIdResponse = OrchestrationFindByIdResponses[keyof OrchestrationFindByIdResponses];
+export type OrchestrationUpdateByIdData = {
+    body?: OrchestrationPartialExcludingIdWorkspace;
+    path: {
+        workspaceId: string;
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations/{id}';
+};
+export type OrchestrationUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Orchestration not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OrchestrationUpdateByIdError = OrchestrationUpdateByIdErrors[keyof OrchestrationUpdateByIdErrors];
+export type OrchestrationUpdateByIdResponses = {
+    /**
+     * Orchestration PATCH success
+     */
+    204: unknown;
+};
+export type OrchestrationFindByWorkspaceData = {
+    body?: never;
+    path: {
+        workspaceId: string;
+    };
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces/{workspaceId}/orchestrations';
+};
+export type OrchestrationFindByWorkspaceErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OrchestrationFindByWorkspaceError = OrchestrationFindByWorkspaceErrors[keyof OrchestrationFindByWorkspaceErrors];
+export type OrchestrationFindByWorkspaceResponses = {
+    /**
+     * Array of Orchestration model instances with pagination
+     */
+    200: {
+        orchestrations?: Array<OrchestrationWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type OrchestrationFindByWorkspaceResponse = OrchestrationFindByWorkspaceResponses[keyof OrchestrationFindByWorkspaceResponses];
+export type OrchestrationCreateData = {
+    body?: NewOrchestration;
+    path: {
+        workspaceId: string;
+    };
+    query?: never;
+    url: '/workspaces/{workspaceId}/orchestrations';
+};
+export type OrchestrationCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type OrchestrationCreateError = OrchestrationCreateErrors[keyof OrchestrationCreateErrors];
+export type OrchestrationCreateResponses = {
+    /**
+     * Orchestration model instance
+     */
+    200: Orchestration;
+};
+export type OrchestrationCreateResponse = OrchestrationCreateResponses[keyof OrchestrationCreateResponses];
+export type WorkspaceDeleteByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{id}';
+};
+export type WorkspaceDeleteByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Workspace not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type WorkspaceDeleteByIdError = WorkspaceDeleteByIdErrors[keyof WorkspaceDeleteByIdErrors];
+export type WorkspaceDeleteByIdResponses = {
+    /**
+     * Workspace DELETE success
+     */
+    204: unknown;
+};
+export type WorkspaceFindByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{id}';
+};
+export type WorkspaceFindByIdErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Workspace not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type WorkspaceFindByIdError = WorkspaceFindByIdErrors[keyof WorkspaceFindByIdErrors];
+export type WorkspaceFindByIdResponses = {
+    /**
+     * Workspace model instance
+     */
+    200: WorkspaceWithRelations;
+};
+export type WorkspaceFindByIdResponse = WorkspaceFindByIdResponses[keyof WorkspaceFindByIdResponses];
+export type WorkspaceUpdateByIdData = {
+    body?: WorkspacePartialExcludingIdOwnerTimeCreatedLastEdited;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/workspaces/{id}';
+};
+export type WorkspaceUpdateByIdErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Forbidden - Access denied
+     */
+    403: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Not Found - Workspace not found
+     */
+    404: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type WorkspaceUpdateByIdError = WorkspaceUpdateByIdErrors[keyof WorkspaceUpdateByIdErrors];
+export type WorkspaceUpdateByIdResponses = {
+    /**
+     * Workspace PATCH success
+     */
+    204: unknown;
+};
+export type WorkspaceFindData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/workspaces';
+};
+export type WorkspaceFindErrors = {
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type WorkspaceFindError = WorkspaceFindErrors[keyof WorkspaceFindErrors];
+export type WorkspaceFindResponses = {
+    /**
+     * Array of Workspace model instances with pagination
+     */
+    200: {
+        workspaces?: Array<WorkspaceWithRelations>;
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+};
+export type WorkspaceFindResponse = WorkspaceFindResponses[keyof WorkspaceFindResponses];
+export type WorkspaceCreateData = {
+    body?: NewWorkspace;
+    path?: never;
+    query?: never;
+    url: '/workspaces';
+};
+export type WorkspaceCreateErrors = {
+    /**
+     * Bad Request - Invalid input data
+     */
+    400: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unauthorized - Authentication required
+     */
+    401: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+    /**
+     * Unprocessable Entity - Validation failed
+     */
+    422: {
+        error?: {
+            statusCode?: number;
+            name?: string;
+            message?: string;
+        };
+    };
+};
+export type WorkspaceCreateError = WorkspaceCreateErrors[keyof WorkspaceCreateErrors];
+export type WorkspaceCreateResponses = {
+    /**
+     * Workspace model instance
+     */
+    200: Workspace;
+};
+export type WorkspaceCreateResponse = WorkspaceCreateResponses[keyof WorkspaceCreateResponses];
+//# sourceMappingURL=types.gen.d.ts.map