// This file is auto-generated by @hey-api/openapi-ts

export type ClientOptions = {
    baseUrl: `${string}://${string}` | (string & {});
};

export type Agent = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: AgentSpec;
    status?: Status;
};

export type AgentSource = {
    image?: string;
    repository?: Repository;
};

export type AgentSpec = {
    description?: string;
    mcpServers?: Array<ResourceRef> | null;
    modelName?: string;
    modelProvider?: string;
    source?: AgentSource;
    title?: string;
};

export type ApplyResult = {
    apiVersion?: string;
    error?: string;
    kind?: string;
    name: string;
    namespace?: string;
    status: string;
    tag?: string;
};

export type ApplyResultsResponse = {
    results: Array<ApplyResult> | null;
};

export type Condition = {
    lastTransitionTime?: string;
    message?: string;
    reason?: string;
    status: string;
    type: string;
};

export type Deployment = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: DeploymentSpec;
    status?: Status;
};

export type DeploymentRef = {
    name: string;
    namespace?: string;
};

export type DeploymentSpec = {
    deploymentRefs?: Array<DeploymentRef> | null;
    desiredState?: string;
    env?: {
        [key: string]: string;
    };
    runtimeConfig?: {
        [key: string]: unknown;
    };
    runtimeRef: ResourceRef;
    targetRef: ResourceRef;
};

export type ErrorDetail = {
    /**
     * Where the error occurred, e.g. 'body.items[3].tags' or 'path.thing-id'
     */
    location?: string;
    /**
     * Error message text
     */
    message?: string;
    /**
     * The value at the given location
     */
    value?: unknown;
};

export type ErrorModel = {
    /**
     * A human-readable explanation specific to this occurrence of the problem.
     */
    detail?: string;
    /**
     * Optional list of individual error details
     */
    errors?: Array<ErrorDetail> | null;
    /**
     * A URI reference that identifies the specific occurrence of the problem.
     */
    instance?: string;
    /**
     * HTTP status code
     */
    status?: number;
    /**
     * A short, human-readable summary of the problem type. This value should not change between occurrences of the error.
     */
    title?: string;
    /**
     * A URI reference to human-readable documentation for the error.
     */
    type?: string;
};

export type HealthBody = {
    /**
     * Platform mode
     */
    platform_mode?: 'docker' | 'kubernetes';
    /**
     * Health status
     */
    status: string;
};

export type ListOutputAgentBody = {
    items: Array<Agent> | null;
    nextCursor?: string;
};

export type ListOutputDeploymentBody = {
    items: Array<Deployment> | null;
    nextCursor?: string;
};

export type ListOutputMcpServerBody = {
    items: Array<McpServer> | null;
    nextCursor?: string;
};

export type ListOutputPromptBody = {
    items: Array<Prompt> | null;
    nextCursor?: string;
};

export type ListOutputRuntimeBody = {
    items: Array<Runtime> | null;
    nextCursor?: string;
};

export type ListOutputSkillBody = {
    items: Array<Skill> | null;
    nextCursor?: string;
};

export type McpArgument = {
    choices?: Array<string> | null;
    default?: string;
    description?: string;
    format?: string;
    isRepeated?: boolean;
    isRequired?: boolean;
    isSecret?: boolean;
    name?: string;
    placeholder?: string;
    type: string;
    value?: string;
    valueHint?: string;
    variables?: {
        [key: string]: McpInputVariable;
    };
};

export type McpInputVariable = {
    choices?: Array<string> | null;
    default?: string;
    description?: string;
    format?: string;
    isRequired?: boolean;
    isSecret?: boolean;
    placeholder?: string;
    value?: string;
};

export type McpKeyValueInput = {
    choices?: Array<string> | null;
    default?: string;
    description?: string;
    format?: string;
    isRequired?: boolean;
    isSecret?: boolean;
    name: string;
    placeholder?: string;
    value?: string;
    variables?: {
        [key: string]: McpInputVariable;
    };
};

export type McpPackage = {
    environmentVariables?: Array<McpKeyValueInput> | null;
    fileSha256?: string;
    identifier: string;
    packageArguments?: Array<McpArgument> | null;
    registryBaseUrl?: string;
    registryType: string;
    runtimeArguments?: Array<McpArgument> | null;
    runtimeHint?: string;
    transport: McpTransport;
    version?: string;
};

export type McpServer = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: McpServerSpec;
    status?: Status;
};

export type McpServerSource = {
    package?: McpPackage;
    repository?: Repository;
};

export type McpServerSpec = {
    description?: string;
    remote?: McpTransport;
    source?: McpServerSource;
    title?: string;
};

export type McpTransport = {
    headers?: Array<McpKeyValueInput> | null;
    type: string;
    url?: string;
};

export type ObjectMeta = {
    annotations?: {
        [key: string]: string;
    };
    createdAt?: string;
    deletionTimestamp?: string;
    labels?: {
        [key: string]: string;
    };
    name: string;
    namespace?: string;
    tag?: string;
    uid?: string;
    updatedAt?: string;
};

export type PingBody = {
    /**
     * Ping response
     */
    pong: boolean;
};

export type Prompt = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: PromptSpec;
    status?: Status;
};

export type PromptSpec = {
    content?: string;
    description?: string;
};

export type Repository = {
    branch?: string;
    commit?: string;
    subfolder?: string;
    url?: string;
};

export type ResourceRef = {
    kind: string;
    name: string;
    namespace?: string;
    tag?: string;
};

export type Runtime = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: RuntimeSpec;
    status?: Status;
};

export type RuntimeSpec = {
    config?: {
        [key: string]: unknown;
    };
    telemetryEndpoint?: string;
    type: string;
};

export type Skill = {
    apiVersion: string;
    kind: string;
    metadata: ObjectMeta;
    spec: SkillSpec;
    status?: Status;
};

export type SkillSource = {
    repository?: Repository;
};

export type SkillSpec = {
    description?: string;
    source?: SkillSource;
    title?: string;
};

export type Status = {
    conditions?: Array<Condition> | null;
    raw?: unknown;
};

export type VersionBody = {
    /**
     * Build timestamp
     */
    build_time: string;
    /**
     * Git commit SHA
     */
    git_commit: string;
    /**
     * Application version
     */
    version: string;
};

export type ListAgentsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/agents';
};

export type ListAgentsErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListAgentsError = ListAgentsErrors[keyof ListAgentsErrors];

export type ListAgentsResponses = {
    /**
     * OK
     */
    200: ListOutputAgentBody;
};

export type ListAgentsResponse = ListAgentsResponses[keyof ListAgentsResponses];

export type GetLatestAgentData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/agents/{name}';
};

export type GetLatestAgentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestAgentError = GetLatestAgentErrors[keyof GetLatestAgentErrors];

export type GetLatestAgentResponses = {
    /**
     * OK
     */
    200: Agent;
};

export type GetLatestAgentResponse = GetLatestAgentResponses[keyof GetLatestAgentResponses];

export type DeleteAgentData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/agents/{name}/{tag}';
};

export type DeleteAgentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteAgentError = DeleteAgentErrors[keyof DeleteAgentErrors];

export type DeleteAgentResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeleteAgentResponse = DeleteAgentResponses[keyof DeleteAgentResponses];

export type GetAgentData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/agents/{name}/{tag}';
};

export type GetAgentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetAgentError = GetAgentErrors[keyof GetAgentErrors];

export type GetAgentResponses = {
    /**
     * OK
     */
    200: Agent;
};

export type GetAgentResponse = GetAgentResponses[keyof GetAgentResponses];

export type ListTagsAgentData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/agents/{name}/tags';
};

export type ListTagsAgentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListTagsAgentError = ListTagsAgentErrors[keyof ListTagsAgentErrors];

export type ListTagsAgentResponses = {
    /**
     * OK
     */
    200: ListOutputAgentBody;
};

export type ListTagsAgentResponse = ListTagsAgentResponses[keyof ListTagsAgentResponses];

export type DeleteBatchData = {
    body: Blob | File;
    path?: never;
    query?: {
        /**
         * Run validation without mutating the store. Defaults to false.
         */
        dryRun?: boolean;
    };
    url: '/v0/apply';
};

export type DeleteBatchErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteBatchError = DeleteBatchErrors[keyof DeleteBatchErrors];

export type DeleteBatchResponses = {
    /**
     * OK
     */
    200: ApplyResultsResponse;
};

export type DeleteBatchResponse = DeleteBatchResponses[keyof DeleteBatchResponses];

export type ApplyBatchData = {
    body: Blob | File;
    path?: never;
    query?: {
        /**
         * Run validation without mutating the store. Defaults to false.
         */
        dryRun?: boolean;
    };
    url: '/v0/apply';
};

export type ApplyBatchErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ApplyBatchError = ApplyBatchErrors[keyof ApplyBatchErrors];

export type ApplyBatchResponses = {
    /**
     * OK
     */
    200: ApplyResultsResponse;
};

export type ApplyBatchResponse = ApplyBatchResponses[keyof ApplyBatchResponses];

export type ListDeploymentsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/deployments';
};

export type ListDeploymentsErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListDeploymentsError = ListDeploymentsErrors[keyof ListDeploymentsErrors];

export type ListDeploymentsResponses = {
    /**
     * OK
     */
    200: ListOutputDeploymentBody;
};

export type ListDeploymentsResponse = ListDeploymentsResponses[keyof ListDeploymentsResponses];

export type DeleteDeploymentData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/deployments/{name}';
};

export type DeleteDeploymentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteDeploymentError = DeleteDeploymentErrors[keyof DeleteDeploymentErrors];

export type DeleteDeploymentResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeleteDeploymentResponse = DeleteDeploymentResponses[keyof DeleteDeploymentResponses];

export type GetLatestDeploymentData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/deployments/{name}';
};

export type GetLatestDeploymentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestDeploymentError = GetLatestDeploymentErrors[keyof GetLatestDeploymentErrors];

export type GetLatestDeploymentResponses = {
    /**
     * OK
     */
    200: Deployment;
};

export type GetLatestDeploymentResponse = GetLatestDeploymentResponses[keyof GetLatestDeploymentResponses];

export type ApplyDeploymentData = {
    body?: Deployment;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/deployments/{name}';
};

export type ApplyDeploymentErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ApplyDeploymentError = ApplyDeploymentErrors[keyof ApplyDeploymentErrors];

export type ApplyDeploymentResponses = {
    /**
     * OK
     */
    200: Deployment;
};

export type ApplyDeploymentResponse = ApplyDeploymentResponses[keyof ApplyDeploymentResponses];

export type GetHealthV0Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v0/health';
};

export type GetHealthV0Errors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetHealthV0Error = GetHealthV0Errors[keyof GetHealthV0Errors];

export type GetHealthV0Responses = {
    /**
     * OK
     */
    200: HealthBody;
};

export type GetHealthV0Response = GetHealthV0Responses[keyof GetHealthV0Responses];

export type ListMcpserversData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/mcpservers';
};

export type ListMcpserversErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListMcpserversError = ListMcpserversErrors[keyof ListMcpserversErrors];

export type ListMcpserversResponses = {
    /**
     * OK
     */
    200: ListOutputMcpServerBody;
};

export type ListMcpserversResponse = ListMcpserversResponses[keyof ListMcpserversResponses];

export type GetLatestMcpserverData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/mcpservers/{name}';
};

export type GetLatestMcpserverErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestMcpserverError = GetLatestMcpserverErrors[keyof GetLatestMcpserverErrors];

export type GetLatestMcpserverResponses = {
    /**
     * OK
     */
    200: McpServer;
};

export type GetLatestMcpserverResponse = GetLatestMcpserverResponses[keyof GetLatestMcpserverResponses];

export type DeleteMcpserverData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/mcpservers/{name}/{tag}';
};

export type DeleteMcpserverErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteMcpserverError = DeleteMcpserverErrors[keyof DeleteMcpserverErrors];

export type DeleteMcpserverResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeleteMcpserverResponse = DeleteMcpserverResponses[keyof DeleteMcpserverResponses];

export type GetMcpserverData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/mcpservers/{name}/{tag}';
};

export type GetMcpserverErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetMcpserverError = GetMcpserverErrors[keyof GetMcpserverErrors];

export type GetMcpserverResponses = {
    /**
     * OK
     */
    200: McpServer;
};

export type GetMcpserverResponse = GetMcpserverResponses[keyof GetMcpserverResponses];

export type ListTagsMcpserverData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/mcpservers/{name}/tags';
};

export type ListTagsMcpserverErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListTagsMcpserverError = ListTagsMcpserverErrors[keyof ListTagsMcpserverErrors];

export type ListTagsMcpserverResponses = {
    /**
     * OK
     */
    200: ListOutputMcpServerBody;
};

export type ListTagsMcpserverResponse = ListTagsMcpserverResponses[keyof ListTagsMcpserverResponses];

export type PingV0Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v0/ping';
};

export type PingV0Errors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type PingV0Error = PingV0Errors[keyof PingV0Errors];

export type PingV0Responses = {
    /**
     * OK
     */
    200: PingBody;
};

export type PingV0Response = PingV0Responses[keyof PingV0Responses];

export type ListPromptsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/prompts';
};

export type ListPromptsErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListPromptsError = ListPromptsErrors[keyof ListPromptsErrors];

export type ListPromptsResponses = {
    /**
     * OK
     */
    200: ListOutputPromptBody;
};

export type ListPromptsResponse = ListPromptsResponses[keyof ListPromptsResponses];

export type GetLatestPromptData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/prompts/{name}';
};

export type GetLatestPromptErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestPromptError = GetLatestPromptErrors[keyof GetLatestPromptErrors];

export type GetLatestPromptResponses = {
    /**
     * OK
     */
    200: Prompt;
};

export type GetLatestPromptResponse = GetLatestPromptResponses[keyof GetLatestPromptResponses];

export type DeletePromptData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/prompts/{name}/{tag}';
};

export type DeletePromptErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeletePromptError = DeletePromptErrors[keyof DeletePromptErrors];

export type DeletePromptResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeletePromptResponse = DeletePromptResponses[keyof DeletePromptResponses];

export type GetPromptData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/prompts/{name}/{tag}';
};

export type GetPromptErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetPromptError = GetPromptErrors[keyof GetPromptErrors];

export type GetPromptResponses = {
    /**
     * OK
     */
    200: Prompt;
};

export type GetPromptResponse = GetPromptResponses[keyof GetPromptResponses];

export type ListTagsPromptData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/prompts/{name}/tags';
};

export type ListTagsPromptErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListTagsPromptError = ListTagsPromptErrors[keyof ListTagsPromptErrors];

export type ListTagsPromptResponses = {
    /**
     * OK
     */
    200: ListOutputPromptBody;
};

export type ListTagsPromptResponse = ListTagsPromptResponses[keyof ListTagsPromptResponses];

export type ListRuntimesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/runtimes';
};

export type ListRuntimesErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListRuntimesError = ListRuntimesErrors[keyof ListRuntimesErrors];

export type ListRuntimesResponses = {
    /**
     * OK
     */
    200: ListOutputRuntimeBody;
};

export type ListRuntimesResponse = ListRuntimesResponses[keyof ListRuntimesResponses];

export type DeleteRuntimeData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/runtimes/{name}';
};

export type DeleteRuntimeErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteRuntimeError = DeleteRuntimeErrors[keyof DeleteRuntimeErrors];

export type DeleteRuntimeResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeleteRuntimeResponse = DeleteRuntimeResponses[keyof DeleteRuntimeResponses];

export type GetLatestRuntimeData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/runtimes/{name}';
};

export type GetLatestRuntimeErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestRuntimeError = GetLatestRuntimeErrors[keyof GetLatestRuntimeErrors];

export type GetLatestRuntimeResponses = {
    /**
     * OK
     */
    200: Runtime;
};

export type GetLatestRuntimeResponse = GetLatestRuntimeResponses[keyof GetLatestRuntimeResponses];

export type ApplyRuntimeData = {
    body?: Runtime;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/runtimes/{name}';
};

export type ApplyRuntimeErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ApplyRuntimeError = ApplyRuntimeErrors[keyof ApplyRuntimeErrors];

export type ApplyRuntimeResponses = {
    /**
     * OK
     */
    200: Runtime;
};

export type ApplyRuntimeResponse = ApplyRuntimeResponses[keyof ApplyRuntimeResponses];

export type ListSkillsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Namespace (defaults to 'default'; 'all' lists across all namespaces).
         */
        namespace?: string;
        /**
         * Max items to return (default 50).
         */
        limit?: number;
        /**
         * Opaque pagination cursor.
         */
        cursor?: string;
        /**
         * Label selector: key=value,key2=value2.
         */
        labels?: string;
        /**
         * Restrict the result set to one tag value (tagged artifact kinds only).
         */
        tag?: string;
        /**
         * Only return the literal latest tag per (namespace, name). Equivalent to tag=latest for tagged kinds.
         */
        latestOnly?: boolean;
        /**
         * Include rows with a deletionTimestamp.
         */
        includeTerminating?: boolean;
    };
    url: '/v0/skills';
};

export type ListSkillsErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListSkillsError = ListSkillsErrors[keyof ListSkillsErrors];

export type ListSkillsResponses = {
    /**
     * OK
     */
    200: ListOutputSkillBody;
};

export type ListSkillsResponse = ListSkillsResponses[keyof ListSkillsResponses];

export type GetLatestSkillData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/skills/{name}';
};

export type GetLatestSkillErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetLatestSkillError = GetLatestSkillErrors[keyof GetLatestSkillErrors];

export type GetLatestSkillResponses = {
    /**
     * OK
     */
    200: Skill;
};

export type GetLatestSkillResponse = GetLatestSkillResponses[keyof GetLatestSkillResponses];

export type DeleteSkillData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
        /**
         * Skip provider-specific teardown and only remove the registry record.
         */
        force?: boolean;
    };
    url: '/v0/skills/{name}/{tag}';
};

export type DeleteSkillErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type DeleteSkillError = DeleteSkillErrors[keyof DeleteSkillErrors];

export type DeleteSkillResponses = {
    /**
     * No Content
     */
    204: void;
};

export type DeleteSkillResponse = DeleteSkillResponses[keyof DeleteSkillResponses];

export type GetSkillData = {
    body?: never;
    path: {
        name: string;
        tag: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/skills/{name}/{tag}';
};

export type GetSkillErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetSkillError = GetSkillErrors[keyof GetSkillErrors];

export type GetSkillResponses = {
    /**
     * OK
     */
    200: Skill;
};

export type GetSkillResponse = GetSkillResponses[keyof GetSkillResponses];

export type ListTagsSkillData = {
    body?: never;
    path: {
        name: string;
    };
    query?: {
        /**
         * Namespace (internal; defaults to 'default').
         */
        namespace?: string;
    };
    url: '/v0/skills/{name}/tags';
};

export type ListTagsSkillErrors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type ListTagsSkillError = ListTagsSkillErrors[keyof ListTagsSkillErrors];

export type ListTagsSkillResponses = {
    /**
     * OK
     */
    200: ListOutputSkillBody;
};

export type ListTagsSkillResponse = ListTagsSkillResponses[keyof ListTagsSkillResponses];

export type GetVersionV0Data = {
    body?: never;
    path?: never;
    query?: never;
    url: '/v0/version';
};

export type GetVersionV0Errors = {
    /**
     * Error
     */
    default: ErrorModel;
};

export type GetVersionV0Error = GetVersionV0Errors[keyof GetVersionV0Errors];

export type GetVersionV0Responses = {
    /**
     * OK
     */
    200: VersionBody;
};

export type GetVersionV0Response = GetVersionV0Responses[keyof GetVersionV0Responses];
