From 1378695c5fdfa8993acbee9b7c4b5c7a947fb0d7 Mon Sep 17 00:00:00 2001 From: "fern-api[bot]" <115122769+fern-api[bot]@users.noreply.github.com> Date: Wed, 6 May 2026 14:28:35 +0000 Subject: [PATCH] SDK regeneration --- .fern/metadata.json | 8 +- src/BaseClient.ts | 4 +- src/Client.ts | 24 ++ .../alphaSectionVersions/client/Client.ts | 374 +++++++++++++++++ .../alphaSectionVersions/client/index.ts | 1 + .../resources/alphaSectionVersions/index.ts | 1 + .../resources/alphaSections/client/Client.ts | 341 ++++++++++++++++ .../resources/alphaSections/client/index.ts | 1 + .../client/requests/UpdateSectionRequest.ts | 12 + .../alphaSections/client/requests/index.ts | 1 + src/api/resources/alphaSections/index.ts | 1 + .../alphaTemplateVersions/client/Client.ts | 374 +++++++++++++++++ .../alphaTemplateVersions/client/index.ts | 1 + .../resources/alphaTemplateVersions/index.ts | 1 + .../resources/alphaTemplates/client/Client.ts | 346 ++++++++++++++++ .../resources/alphaTemplates/client/index.ts | 1 + .../client/requests/UpdateTemplateRequest.ts | 12 + .../alphaTemplates/client/requests/index.ts | 1 + src/api/resources/alphaTemplates/index.ts | 1 + src/api/resources/index.ts | 6 + src/api/types/AgentsCreateExpertReference.ts | 2 + src/api/types/AgentsExpertReference.ts | 2 + src/api/types/AgentsRegistryExpert.ts | 2 + src/api/types/ArrayNode.ts | 16 + src/api/types/BoolNode.ts | 9 + src/api/types/FieldDefinition.ts | 11 + src/api/types/NumberNode.ts | 15 + src/api/types/ObjectNode.ts | 15 + src/api/types/OutputSchema.ts | 5 + src/api/types/Section.ts | 26 ++ src/api/types/SectionGeneration.ts | 11 + src/api/types/SectionInstructions.ts | 10 + src/api/types/SectionVersion.ts | 11 + src/api/types/StatusResponse.ts | 5 + src/api/types/StringNode.ts | 13 + src/api/types/Template.ts | 25 ++ src/api/types/TemplateGeneration.ts | 9 + src/api/types/TemplateInstructions.ts | 6 + src/api/types/TemplateVersion.ts | 11 + src/api/types/index.ts | 16 + .../resources/alphaSections/client/index.ts | 1 + .../client/requests/UpdateSectionRequest.ts | 24 ++ .../alphaSections/client/requests/index.ts | 1 + .../resources/alphaSections/index.ts | 1 + .../resources/alphaTemplates/client/index.ts | 1 + .../client/requests/UpdateTemplateRequest.ts | 24 ++ .../alphaTemplates/client/requests/index.ts | 1 + .../resources/alphaTemplates/index.ts | 1 + src/serialization/resources/index.ts | 4 + .../types/AgentsCreateExpertReference.ts | 2 + .../types/AgentsExpertReference.ts | 2 + .../types/AgentsRegistryExpert.ts | 2 + src/serialization/types/ArrayNode.ts | 26 ++ src/serialization/types/BoolNode.ts | 20 + src/serialization/types/FieldDefinition.ts | 20 + src/serialization/types/NumberNode.ts | 26 ++ src/serialization/types/ObjectNode.ts | 24 ++ src/serialization/types/OutputSchema.ts | 26 ++ src/serialization/types/Section.ts | 35 ++ src/serialization/types/SectionGeneration.ts | 23 ++ .../types/SectionInstructions.ts | 22 + src/serialization/types/SectionVersion.ts | 21 + src/serialization/types/StatusResponse.ts | 16 + src/serialization/types/StringNode.ts | 24 ++ src/serialization/types/Template.ts | 35 ++ src/serialization/types/TemplateGeneration.ts | 22 + .../types/TemplateInstructions.ts | 18 + src/serialization/types/TemplateVersion.ts | 21 + src/serialization/types/index.ts | 16 + tests/wire/agents.test.ts | 4 + tests/wire/alphaSectionVersions.test.ts | 238 +++++++++++ tests/wire/alphaSections.test.ts | 309 ++++++++++++++ tests/wire/alphaTemplateVersions.test.ts | 258 ++++++++++++ tests/wire/alphaTemplates.test.ts | 381 ++++++++++++++++++ 74 files changed, 3375 insertions(+), 5 deletions(-) create mode 100644 src/api/resources/alphaSectionVersions/client/Client.ts create mode 100644 src/api/resources/alphaSectionVersions/client/index.ts create mode 100644 src/api/resources/alphaSectionVersions/index.ts create mode 100644 src/api/resources/alphaSections/client/Client.ts create mode 100644 src/api/resources/alphaSections/client/index.ts create mode 100644 src/api/resources/alphaSections/client/requests/UpdateSectionRequest.ts create mode 100644 src/api/resources/alphaSections/client/requests/index.ts create mode 100644 src/api/resources/alphaSections/index.ts create mode 100644 src/api/resources/alphaTemplateVersions/client/Client.ts create mode 100644 src/api/resources/alphaTemplateVersions/client/index.ts create mode 100644 src/api/resources/alphaTemplateVersions/index.ts create mode 100644 src/api/resources/alphaTemplates/client/Client.ts create mode 100644 src/api/resources/alphaTemplates/client/index.ts create mode 100644 src/api/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts create mode 100644 src/api/resources/alphaTemplates/client/requests/index.ts create mode 100644 src/api/resources/alphaTemplates/index.ts create mode 100644 src/api/types/ArrayNode.ts create mode 100644 src/api/types/BoolNode.ts create mode 100644 src/api/types/FieldDefinition.ts create mode 100644 src/api/types/NumberNode.ts create mode 100644 src/api/types/ObjectNode.ts create mode 100644 src/api/types/OutputSchema.ts create mode 100644 src/api/types/Section.ts create mode 100644 src/api/types/SectionGeneration.ts create mode 100644 src/api/types/SectionInstructions.ts create mode 100644 src/api/types/SectionVersion.ts create mode 100644 src/api/types/StatusResponse.ts create mode 100644 src/api/types/StringNode.ts create mode 100644 src/api/types/Template.ts create mode 100644 src/api/types/TemplateGeneration.ts create mode 100644 src/api/types/TemplateInstructions.ts create mode 100644 src/api/types/TemplateVersion.ts create mode 100644 src/serialization/resources/alphaSections/client/index.ts create mode 100644 src/serialization/resources/alphaSections/client/requests/UpdateSectionRequest.ts create mode 100644 src/serialization/resources/alphaSections/client/requests/index.ts create mode 100644 src/serialization/resources/alphaSections/index.ts create mode 100644 src/serialization/resources/alphaTemplates/client/index.ts create mode 100644 src/serialization/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts create mode 100644 src/serialization/resources/alphaTemplates/client/requests/index.ts create mode 100644 src/serialization/resources/alphaTemplates/index.ts create mode 100644 src/serialization/types/ArrayNode.ts create mode 100644 src/serialization/types/BoolNode.ts create mode 100644 src/serialization/types/FieldDefinition.ts create mode 100644 src/serialization/types/NumberNode.ts create mode 100644 src/serialization/types/ObjectNode.ts create mode 100644 src/serialization/types/OutputSchema.ts create mode 100644 src/serialization/types/Section.ts create mode 100644 src/serialization/types/SectionGeneration.ts create mode 100644 src/serialization/types/SectionInstructions.ts create mode 100644 src/serialization/types/SectionVersion.ts create mode 100644 src/serialization/types/StatusResponse.ts create mode 100644 src/serialization/types/StringNode.ts create mode 100644 src/serialization/types/Template.ts create mode 100644 src/serialization/types/TemplateGeneration.ts create mode 100644 src/serialization/types/TemplateInstructions.ts create mode 100644 src/serialization/types/TemplateVersion.ts create mode 100644 tests/wire/alphaSectionVersions.test.ts create mode 100644 tests/wire/alphaSections.test.ts create mode 100644 tests/wire/alphaTemplateVersions.test.ts create mode 100644 tests/wire/alphaTemplates.test.ts diff --git a/.fern/metadata.json b/.fern/metadata.json index 72e5ce8b..6959a60a 100644 --- a/.fern/metadata.json +++ b/.fern/metadata.json @@ -1,5 +1,5 @@ { - "cliVersion": "4.86.1", + "cliVersion": "4.107.0", "generatorName": "fernapi/fern-typescript-node-sdk", "generatorVersion": "3.54.0", "generatorConfig": { @@ -15,7 +15,9 @@ }, "packageJson": { "scripts": { - "test:integration": "vitest --config vitest.integration.config.mts" + "test:integration": "pnpm test:integration:main && pnpm test:integration:empty-state", + "test:integration:main": "vitest run --config vitest.integration.config.mts --project integration", + "test:integration:empty-state": "vitest run --config vitest.integration.config.mts --project integration-empty-state" }, "exports": { "./utils": { @@ -32,6 +34,6 @@ } } }, - "originGitCommit": "23bce53307f0836f2dcd50e82ef0aba136e7ec2f", + "originGitCommit": "123fb59ee8ebe34e1243105961afa7b935978cab", "sdkVersion": "0.0.0-dev" } diff --git a/src/BaseClient.ts b/src/BaseClient.ts index 1b76cbaa..27d389e5 100644 --- a/src/BaseClient.ts +++ b/src/BaseClient.ts @@ -10,7 +10,7 @@ export type BaseClientOptions = { /** Specify a custom URL to connect the client to. */ baseUrl?: core.Supplier; /** Override the Tenant-Name header */ - tenantName: core.Supplier; + tenantName?: core.Supplier; /** Additional headers to include in requests. */ headers?: Record | null | undefined>; /** The default maximum time to wait for a response in seconds. */ @@ -31,7 +31,7 @@ export interface BaseRequestOptions { /** A hook to abort the request. */ abortSignal?: AbortSignal; /** Override the Tenant-Name header */ - tenantName?: string; + tenantName?: string | undefined; /** Additional query string parameters to include in the request. */ queryParams?: Record; /** Additional headers to include in the request. */ diff --git a/src/Client.ts b/src/Client.ts index 7aa94bd7..55e47765 100644 --- a/src/Client.ts +++ b/src/Client.ts @@ -1,6 +1,10 @@ // This file was auto-generated by Fern from our API Definition. import { AgentsClient } from "./api/resources/agents/client/Client.js"; +import { AlphaSectionsClient } from "./api/resources/alphaSections/client/Client.js"; +import { AlphaSectionVersionsClient } from "./api/resources/alphaSectionVersions/client/Client.js"; +import { AlphaTemplatesClient } from "./api/resources/alphaTemplates/client/Client.js"; +import { AlphaTemplateVersionsClient } from "./api/resources/alphaTemplateVersions/client/Client.js"; import { AuthClient } from "./api/resources/auth/client/Client.js"; import { CodesClient } from "./api/resources/codes/client/Client.js"; import { DocumentsClient } from "./api/resources/documents/client/Client.js"; @@ -30,6 +34,10 @@ export class CortiClient { protected _documents: DocumentsClient | undefined; protected _templates: TemplatesClient | undefined; protected _codes: CodesClient | undefined; + protected _alphaTemplates: AlphaTemplatesClient | undefined; + protected _alphaTemplateVersions: AlphaTemplateVersionsClient | undefined; + protected _alphaSections: AlphaSectionsClient | undefined; + protected _alphaSectionVersions: AlphaSectionVersionsClient | undefined; protected _agents: AgentsClient | undefined; protected _stream: StreamClient | undefined; protected _transcribe: TranscribeClient | undefined; @@ -70,6 +78,22 @@ export class CortiClient { return (this._codes ??= new CodesClient(this._options)); } + public get alphaTemplates(): AlphaTemplatesClient { + return (this._alphaTemplates ??= new AlphaTemplatesClient(this._options)); + } + + public get alphaTemplateVersions(): AlphaTemplateVersionsClient { + return (this._alphaTemplateVersions ??= new AlphaTemplateVersionsClient(this._options)); + } + + public get alphaSections(): AlphaSectionsClient { + return (this._alphaSections ??= new AlphaSectionsClient(this._options)); + } + + public get alphaSectionVersions(): AlphaSectionVersionsClient { + return (this._alphaSectionVersions ??= new AlphaSectionVersionsClient(this._options)); + } + public get agents(): AgentsClient { return (this._agents ??= new AgentsClient(this._options)); } diff --git a/src/api/resources/alphaSectionVersions/client/Client.ts b/src/api/resources/alphaSectionVersions/client/Client.ts new file mode 100644 index 00000000..fc2e00e9 --- /dev/null +++ b/src/api/resources/alphaSectionVersions/client/Client.ts @@ -0,0 +1,374 @@ +// This file was auto-generated by Fern from our API Definition. + +import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js"; +import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js"; +import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js"; +import * as core from "../../../../core/index.js"; +import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js"; +import * as errors from "../../../../errors/index.js"; +import * as serializers from "../../../../serialization/index.js"; +import * as Corti from "../../../index.js"; + +export declare namespace AlphaSectionVersionsClient { + export type Options = BaseClientOptions; + + export interface RequestOptions extends BaseRequestOptions {} +} + +export class AlphaSectionVersionsClient { + protected readonly _options: NormalizedClientOptionsWithAuth; + + constructor(options: AlphaSectionVersionsClient.Options) { + this._options = normalizeClientOptionsWithAuth(options); + } + + /** + * @param {string} sectionID + * @param {string} versionID + * @param {AlphaSectionVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSectionVersions.get("sectionID", "versionID") + */ + public get( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__get(sectionID, versionID, requestOptions)); + } + + private async __get( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}/versions/${core.url.encodePathParam(versionID)}`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.SectionVersion.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "GET", + "/alpha/sections/{sectionID}/versions/{versionID}", + ); + } + + /** + * @param {string} sectionID + * @param {string} versionID + * @param {AlphaSectionVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSectionVersions.delete("sectionID", "versionID") + */ + public delete( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__delete(sectionID, versionID, requestOptions)); + } + + private async __delete( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}/versions/${core.url.encodePathParam(versionID)}`, + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "DELETE", + "/alpha/sections/{sectionID}/versions/{versionID}", + ); + } + + /** + * Sets this version as the published version of the section. + * + * @param {string} sectionID + * @param {string} versionID + * @param {AlphaSectionVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSectionVersions.publish("sectionID", "versionID") + */ + public publish( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__publish(sectionID, versionID, requestOptions)); + } + + private async __publish( + sectionID: string, + versionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}/versions/${core.url.encodePathParam(versionID)}/publish`, + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.StatusResponse.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "POST", + "/alpha/sections/{sectionID}/versions/{versionID}/publish", + ); + } + + /** + * @param {string} sectionID + * @param {AlphaSectionVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaSectionVersions.list("sectionID") + */ + public list( + sectionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__list(sectionID, requestOptions)); + } + + private async __list( + sectionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}/versions`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "GET", + "/alpha/sections/{sectionID}/versions", + ); + } + + /** + * @param {string} sectionID + * @param {AlphaSectionVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaSectionVersions.create("sectionID") + */ + public create( + sectionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__create(sectionID, requestOptions)); + } + + private async __create( + sectionID: string, + requestOptions?: AlphaSectionVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}/versions`, + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "POST", + "/alpha/sections/{sectionID}/versions", + ); + } +} diff --git a/src/api/resources/alphaSectionVersions/client/index.ts b/src/api/resources/alphaSectionVersions/client/index.ts new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/src/api/resources/alphaSectionVersions/client/index.ts @@ -0,0 +1 @@ +export {}; diff --git a/src/api/resources/alphaSectionVersions/index.ts b/src/api/resources/alphaSectionVersions/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/api/resources/alphaSectionVersions/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/api/resources/alphaSections/client/Client.ts b/src/api/resources/alphaSections/client/Client.ts new file mode 100644 index 00000000..f6fdd17a --- /dev/null +++ b/src/api/resources/alphaSections/client/Client.ts @@ -0,0 +1,341 @@ +// This file was auto-generated by Fern from our API Definition. + +import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js"; +import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js"; +import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js"; +import * as core from "../../../../core/index.js"; +import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js"; +import * as errors from "../../../../errors/index.js"; +import * as serializers from "../../../../serialization/index.js"; +import * as Corti from "../../../index.js"; + +export declare namespace AlphaSectionsClient { + export type Options = BaseClientOptions; + + export interface RequestOptions extends BaseRequestOptions {} +} + +export class AlphaSectionsClient { + protected readonly _options: NormalizedClientOptionsWithAuth; + + constructor(options: AlphaSectionsClient.Options) { + this._options = normalizeClientOptionsWithAuth(options); + } + + /** + * @param {string} sectionID + * @param {AlphaSectionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSections.get("sectionID") + */ + public get( + sectionID: string, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__get(sectionID, requestOptions)); + } + + private async __get( + sectionID: string, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.Section.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/alpha/sections/{sectionID}"); + } + + /** + * @param {string} sectionID + * @param {AlphaSectionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSections.delete("sectionID") + */ + public delete( + sectionID: string, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__delete(sectionID, requestOptions)); + } + + private async __delete( + sectionID: string, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}`, + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "DELETE", + "/alpha/sections/{sectionID}", + ); + } + + /** + * @param {string} sectionID + * @param {Corti.UpdateSectionRequest} request + * @param {AlphaSectionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.BadRequestError} + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaSections.update("sectionID") + */ + public update( + sectionID: string, + request: Corti.UpdateSectionRequest = {}, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__update(sectionID, request, requestOptions)); + } + + private async __update( + sectionID: string, + request: Corti.UpdateSectionRequest = {}, + requestOptions?: AlphaSectionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/sections/${core.url.encodePathParam(sectionID)}`, + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions?.queryParams, + requestType: "json", + body: serializers.UpdateSectionRequest.jsonOrThrow(request, { + unrecognizedObjectKeys: "strip", + omitUndefined: true, + }), + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.Section.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Corti.BadRequestError(_response.error.body, _response.rawResponse); + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/alpha/sections/{sectionID}"); + } + + /** + * @param {AlphaSectionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaSections.list() + */ + public list(requestOptions?: AlphaSectionsClient.RequestOptions): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__list(requestOptions)); + } + + private async __list(requestOptions?: AlphaSectionsClient.RequestOptions): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + "alpha/sections", + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/alpha/sections"); + } + + /** + * @param {AlphaSectionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaSections.create() + */ + public create(requestOptions?: AlphaSectionsClient.RequestOptions): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__create(requestOptions)); + } + + private async __create(requestOptions?: AlphaSectionsClient.RequestOptions): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + "alpha/sections", + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/alpha/sections"); + } +} diff --git a/src/api/resources/alphaSections/client/index.ts b/src/api/resources/alphaSections/client/index.ts new file mode 100644 index 00000000..195f9aa8 --- /dev/null +++ b/src/api/resources/alphaSections/client/index.ts @@ -0,0 +1 @@ +export * from "./requests/index.js"; diff --git a/src/api/resources/alphaSections/client/requests/UpdateSectionRequest.ts b/src/api/resources/alphaSections/client/requests/UpdateSectionRequest.ts new file mode 100644 index 00000000..9e5d0e59 --- /dev/null +++ b/src/api/resources/alphaSections/client/requests/UpdateSectionRequest.ts @@ -0,0 +1,12 @@ +// This file was auto-generated by Fern from our API Definition. + +/** + * @example + * {} + */ +export interface UpdateSectionRequest { + name?: string; + language?: string; + description?: string; + labels?: string[]; +} diff --git a/src/api/resources/alphaSections/client/requests/index.ts b/src/api/resources/alphaSections/client/requests/index.ts new file mode 100644 index 00000000..9d16287f --- /dev/null +++ b/src/api/resources/alphaSections/client/requests/index.ts @@ -0,0 +1 @@ +export type { UpdateSectionRequest } from "./UpdateSectionRequest.js"; diff --git a/src/api/resources/alphaSections/index.ts b/src/api/resources/alphaSections/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/api/resources/alphaSections/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/api/resources/alphaTemplateVersions/client/Client.ts b/src/api/resources/alphaTemplateVersions/client/Client.ts new file mode 100644 index 00000000..976f5b19 --- /dev/null +++ b/src/api/resources/alphaTemplateVersions/client/Client.ts @@ -0,0 +1,374 @@ +// This file was auto-generated by Fern from our API Definition. + +import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js"; +import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js"; +import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js"; +import * as core from "../../../../core/index.js"; +import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js"; +import * as errors from "../../../../errors/index.js"; +import * as serializers from "../../../../serialization/index.js"; +import * as Corti from "../../../index.js"; + +export declare namespace AlphaTemplateVersionsClient { + export type Options = BaseClientOptions; + + export interface RequestOptions extends BaseRequestOptions {} +} + +export class AlphaTemplateVersionsClient { + protected readonly _options: NormalizedClientOptionsWithAuth; + + constructor(options: AlphaTemplateVersionsClient.Options) { + this._options = normalizeClientOptionsWithAuth(options); + } + + /** + * @param {string} templateID + * @param {string} versionID + * @param {AlphaTemplateVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplateVersions.get("templateID", "versionID") + */ + public get( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__get(templateID, versionID, requestOptions)); + } + + private async __get( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}/versions/${core.url.encodePathParam(versionID)}`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.TemplateVersion.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "GET", + "/alpha/templates/{templateID}/versions/{versionID}", + ); + } + + /** + * @param {string} templateID + * @param {string} versionID + * @param {AlphaTemplateVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplateVersions.delete("templateID", "versionID") + */ + public delete( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__delete(templateID, versionID, requestOptions)); + } + + private async __delete( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}/versions/${core.url.encodePathParam(versionID)}`, + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "DELETE", + "/alpha/templates/{templateID}/versions/{versionID}", + ); + } + + /** + * Sets this version as the published version of the template. + * + * @param {string} templateID + * @param {string} versionID + * @param {AlphaTemplateVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplateVersions.publish("templateID", "versionID") + */ + public publish( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__publish(templateID, versionID, requestOptions)); + } + + private async __publish( + templateID: string, + versionID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}/versions/${core.url.encodePathParam(versionID)}/publish`, + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.StatusResponse.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "POST", + "/alpha/templates/{templateID}/versions/{versionID}/publish", + ); + } + + /** + * @param {string} templateID + * @param {AlphaTemplateVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaTemplateVersions.list("templateID") + */ + public list( + templateID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__list(templateID, requestOptions)); + } + + private async __list( + templateID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}/versions`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "GET", + "/alpha/templates/{templateID}/versions", + ); + } + + /** + * @param {string} templateID + * @param {AlphaTemplateVersionsClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaTemplateVersions.create("templateID") + */ + public create( + templateID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__create(templateID, requestOptions)); + } + + private async __create( + templateID: string, + requestOptions?: AlphaTemplateVersionsClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}/versions`, + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "POST", + "/alpha/templates/{templateID}/versions", + ); + } +} diff --git a/src/api/resources/alphaTemplateVersions/client/index.ts b/src/api/resources/alphaTemplateVersions/client/index.ts new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/src/api/resources/alphaTemplateVersions/client/index.ts @@ -0,0 +1 @@ +export {}; diff --git a/src/api/resources/alphaTemplateVersions/index.ts b/src/api/resources/alphaTemplateVersions/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/api/resources/alphaTemplateVersions/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/api/resources/alphaTemplates/client/Client.ts b/src/api/resources/alphaTemplates/client/Client.ts new file mode 100644 index 00000000..65212747 --- /dev/null +++ b/src/api/resources/alphaTemplates/client/Client.ts @@ -0,0 +1,346 @@ +// This file was auto-generated by Fern from our API Definition. + +import type { BaseClientOptions, BaseRequestOptions } from "../../../../BaseClient.js"; +import { type NormalizedClientOptionsWithAuth, normalizeClientOptionsWithAuth } from "../../../../BaseClient.js"; +import { mergeHeaders, mergeOnlyDefinedHeaders } from "../../../../core/headers.js"; +import * as core from "../../../../core/index.js"; +import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js"; +import * as errors from "../../../../errors/index.js"; +import * as serializers from "../../../../serialization/index.js"; +import * as Corti from "../../../index.js"; + +export declare namespace AlphaTemplatesClient { + export type Options = BaseClientOptions; + + export interface RequestOptions extends BaseRequestOptions {} +} + +export class AlphaTemplatesClient { + protected readonly _options: NormalizedClientOptionsWithAuth; + + constructor(options: AlphaTemplatesClient.Options) { + this._options = normalizeClientOptionsWithAuth(options); + } + + /** + * @param {string} templateID + * @param {AlphaTemplatesClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplates.get("templateID") + */ + public get( + templateID: string, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__get(templateID, requestOptions)); + } + + private async __get( + templateID: string, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}`, + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.Template.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/alpha/templates/{templateID}"); + } + + /** + * @param {string} templateID + * @param {AlphaTemplatesClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplates.delete("templateID") + */ + public delete( + templateID: string, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__delete(templateID, requestOptions)); + } + + private async __delete( + templateID: string, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}`, + ), + method: "DELETE", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "DELETE", + "/alpha/templates/{templateID}", + ); + } + + /** + * @param {string} templateID + * @param {Corti.UpdateTemplateRequest} request + * @param {AlphaTemplatesClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @throws {@link Corti.BadRequestError} + * @throws {@link Corti.NotFoundError} + * + * @example + * await client.alphaTemplates.update("templateID") + */ + public update( + templateID: string, + request: Corti.UpdateTemplateRequest = {}, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__update(templateID, request, requestOptions)); + } + + private async __update( + templateID: string, + request: Corti.UpdateTemplateRequest = {}, + requestOptions?: AlphaTemplatesClient.RequestOptions, + ): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + `alpha/templates/${core.url.encodePathParam(templateID)}`, + ), + method: "PATCH", + headers: _headers, + contentType: "application/json", + queryParameters: requestOptions?.queryParams, + requestType: "json", + body: serializers.UpdateTemplateRequest.jsonOrThrow(request, { + unrecognizedObjectKeys: "strip", + omitUndefined: true, + }), + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { + data: serializers.Template.parseOrThrow(_response.body, { + unrecognizedObjectKeys: "passthrough", + allowUnrecognizedUnionMembers: true, + allowUnrecognizedEnumValues: true, + skipValidation: true, + breadcrumbsPrefix: ["response"], + }), + rawResponse: _response.rawResponse, + }; + } + + if (_response.error.reason === "status-code") { + switch (_response.error.statusCode) { + case 400: + throw new Corti.BadRequestError(_response.error.body, _response.rawResponse); + case 404: + throw new Corti.NotFoundError(_response.error.body, _response.rawResponse); + default: + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + } + + return handleNonStatusCodeError( + _response.error, + _response.rawResponse, + "PATCH", + "/alpha/templates/{templateID}", + ); + } + + /** + * @param {AlphaTemplatesClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaTemplates.list() + */ + public list(requestOptions?: AlphaTemplatesClient.RequestOptions): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__list(requestOptions)); + } + + private async __list(requestOptions?: AlphaTemplatesClient.RequestOptions): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + "alpha/templates", + ), + method: "GET", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/alpha/templates"); + } + + /** + * @param {AlphaTemplatesClient.RequestOptions} requestOptions - Request-specific configuration. + * + * @example + * await client.alphaTemplates.create() + */ + public create(requestOptions?: AlphaTemplatesClient.RequestOptions): core.HttpResponsePromise { + return core.HttpResponsePromise.fromPromise(this.__create(requestOptions)); + } + + private async __create(requestOptions?: AlphaTemplatesClient.RequestOptions): Promise> { + const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest(); + const _headers: core.Fetcher.Args["headers"] = mergeHeaders( + _authRequest.headers, + this._options?.headers, + mergeOnlyDefinedHeaders({ "Tenant-Name": requestOptions?.tenantName ?? this._options?.tenantName }), + requestOptions?.headers, + ); + const _response = await core.fetcher({ + url: core.url.join( + (await core.Supplier.get(this._options.baseUrl)) ?? + (await core.Supplier.get(this._options.environment)).base, + "alpha/templates", + ), + method: "POST", + headers: _headers, + queryParameters: requestOptions?.queryParams, + timeoutMs: (requestOptions?.timeoutInSeconds ?? this._options?.timeoutInSeconds ?? 60) * 1000, + maxRetries: requestOptions?.maxRetries ?? this._options?.maxRetries, + abortSignal: requestOptions?.abortSignal, + fetchFn: this._options?.fetch, + logging: this._options.logging, + }); + if (_response.ok) { + return { data: undefined, rawResponse: _response.rawResponse }; + } + + if (_response.error.reason === "status-code") { + throw new errors.CortiError({ + statusCode: _response.error.statusCode, + body: _response.error.body, + rawResponse: _response.rawResponse, + }); + } + + return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/alpha/templates"); + } +} diff --git a/src/api/resources/alphaTemplates/client/index.ts b/src/api/resources/alphaTemplates/client/index.ts new file mode 100644 index 00000000..195f9aa8 --- /dev/null +++ b/src/api/resources/alphaTemplates/client/index.ts @@ -0,0 +1 @@ +export * from "./requests/index.js"; diff --git a/src/api/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts b/src/api/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts new file mode 100644 index 00000000..0ab19a77 --- /dev/null +++ b/src/api/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts @@ -0,0 +1,12 @@ +// This file was auto-generated by Fern from our API Definition. + +/** + * @example + * {} + */ +export interface UpdateTemplateRequest { + name?: string; + description?: string; + language?: string; + labels?: string[]; +} diff --git a/src/api/resources/alphaTemplates/client/requests/index.ts b/src/api/resources/alphaTemplates/client/requests/index.ts new file mode 100644 index 00000000..ad5cb816 --- /dev/null +++ b/src/api/resources/alphaTemplates/client/requests/index.ts @@ -0,0 +1 @@ +export type { UpdateTemplateRequest } from "./UpdateTemplateRequest.js"; diff --git a/src/api/resources/alphaTemplates/index.ts b/src/api/resources/alphaTemplates/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/api/resources/alphaTemplates/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/api/resources/index.ts b/src/api/resources/index.ts index 018dfdfd..6acf5a18 100644 --- a/src/api/resources/index.ts +++ b/src/api/resources/index.ts @@ -1,6 +1,12 @@ export * from "./agents/client/requests/index.js"; export * as agents from "./agents/index.js"; export * from "./agents/types/index.js"; +export * from "./alphaSections/client/requests/index.js"; +export * as alphaSections from "./alphaSections/index.js"; +export * as alphaSectionVersions from "./alphaSectionVersions/index.js"; +export * from "./alphaTemplates/client/requests/index.js"; +export * as alphaTemplates from "./alphaTemplates/index.js"; +export * as alphaTemplateVersions from "./alphaTemplateVersions/index.js"; export * as auth from "./auth/index.js"; export * from "./auth/types/index.js"; export * from "./codes/client/requests/index.js"; diff --git a/src/api/types/AgentsCreateExpertReference.ts b/src/api/types/AgentsCreateExpertReference.ts index 733a6184..faa939f2 100644 --- a/src/api/types/AgentsCreateExpertReference.ts +++ b/src/api/types/AgentsCreateExpertReference.ts @@ -13,4 +13,6 @@ export interface AgentsCreateExpertReference { name?: string; /** Optional. Additional system instructions appended to the default system prompt when creating an expert from the registry, extending the expert's behavior. */ systemPrompt?: string; + /** Optional configuration override for the registry expert. Values provided here are deep-merged with the schema defaults declared on the registry expert and validated against its `configSchema`. Ignored when the registry expert has no schema. */ + config?: Record; } diff --git a/src/api/types/AgentsExpertReference.ts b/src/api/types/AgentsExpertReference.ts index c5d5dd72..09c21b14 100644 --- a/src/api/types/AgentsExpertReference.ts +++ b/src/api/types/AgentsExpertReference.ts @@ -13,4 +13,6 @@ export interface AgentsExpertReference { name: string; /** Optional. Additional system instructions appended to the default system prompt when creating an expert from the registry, extending the expert's behavior. */ systemPrompt?: string; + /** The fully resolved configuration for this expert: schema defaults from the registry expert deep-merged with any `config` override supplied at creation. Present only when the source registry expert defined a `configSchema`. */ + resolvedConfig?: Record; } diff --git a/src/api/types/AgentsRegistryExpert.ts b/src/api/types/AgentsRegistryExpert.ts index ef98affa..6bb800f1 100644 --- a/src/api/types/AgentsRegistryExpert.ts +++ b/src/api/types/AgentsRegistryExpert.ts @@ -13,4 +13,6 @@ export interface AgentsRegistryExpert { description: string; /** A list of MCP servers the expert can call, including their authorization types. */ mcpServers?: Corti.AgentsRegistryMcpServer[]; + /** Optional JSON Schema describing the configuration this expert accepts. When present, callers may supply a matching `config` object on `AgentsCreateExpertReference`; values are deep-merged with schema defaults and validated against this schema. */ + configSchema?: Record; } diff --git a/src/api/types/ArrayNode.ts b/src/api/types/ArrayNode.ts new file mode 100644 index 00000000..cddff8a6 --- /dev/null +++ b/src/api/types/ArrayNode.ts @@ -0,0 +1,16 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface ArrayNode { + type: "array"; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description?: string; + items: Corti.OutputSchema; + /** Controls how each array item is rendered in the generated output. Use `bullet` (default), `numbered`, or `plain`, or provide a custom format string containing the `{item}` placeholder. */ + itemFormat?: string; + /** Minimum number of array items to generate. */ + minItems?: number | null; + /** Maximum number of array items to generate. */ + maxItems?: number | null; +} diff --git a/src/api/types/BoolNode.ts b/src/api/types/BoolNode.ts new file mode 100644 index 00000000..9d9d69eb --- /dev/null +++ b/src/api/types/BoolNode.ts @@ -0,0 +1,9 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface BoolNode { + type: "boolean"; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description?: string; + /** The default to output if nothing to output. */ + default?: boolean | null; +} diff --git a/src/api/types/FieldDefinition.ts b/src/api/types/FieldDefinition.ts new file mode 100644 index 00000000..0bf1e301 --- /dev/null +++ b/src/api/types/FieldDefinition.ts @@ -0,0 +1,11 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface FieldDefinition { + /** Use to set a key to reference. */ + key: string; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description: string; + value: Corti.OutputSchema; +} diff --git a/src/api/types/NumberNode.ts b/src/api/types/NumberNode.ts new file mode 100644 index 00000000..553e4038 --- /dev/null +++ b/src/api/types/NumberNode.ts @@ -0,0 +1,15 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface NumberNode { + type: "number"; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description?: string; + /** The default to output if nothing to output. */ + default?: number | null; + /** Can be used to prompt the LLM for specifically allowed numeric values to output. */ + enum?: number[]; + /** Use if a minimum value applies. */ + minimum?: number | null; + /** Use if a maximum value applies. */ + maximum?: number | null; +} diff --git a/src/api/types/ObjectNode.ts b/src/api/types/ObjectNode.ts new file mode 100644 index 00000000..99d070f9 --- /dev/null +++ b/src/api/types/ObjectNode.ts @@ -0,0 +1,15 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface ObjectNode { + type: "object"; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description?: string; + /** Controls how subheadings are rendered in the generated output. Use `inline` (default) for `{key}: {value}\n` or `block` for `{key}\n{value}\n`, or provide a custom format string containing both `{key}` and `{value}` placeholders. Mutually exclusive with `objectFormat`. */ + subheadingFormat?: string; + /** A format string referencing field keys as placeholders (e.g. `{fieldKey}`). All placeholders must correspond to defined field keys. Mutually exclusive with `subheadingFormat`. */ + objectFormat?: string; + /** Define what fields are possible to return in the object. */ + fields?: Corti.FieldDefinition[]; +} diff --git a/src/api/types/OutputSchema.ts b/src/api/types/OutputSchema.ts new file mode 100644 index 00000000..57e6832d --- /dev/null +++ b/src/api/types/OutputSchema.ts @@ -0,0 +1,5 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export type OutputSchema = Corti.StringNode | Corti.NumberNode | Corti.BoolNode | Corti.ObjectNode | Corti.ArrayNode; diff --git a/src/api/types/Section.ts b/src/api/types/Section.ts new file mode 100644 index 00000000..842d201b --- /dev/null +++ b/src/api/types/Section.ts @@ -0,0 +1,26 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface Section { + /** The UUID of the section. */ + id: string; + /** Reference to the section to inherit generation configuration from. Inherits from published version by default. */ + inheritedFromId?: string | null; + /** True if the section was auto-generated as part of an inline section-composed POST /documents request. */ + autoGenerated?: boolean; + /** The name of the section. */ + name: string; + /** The intended language for outputs as BCP 47 tag. */ + language: string; + /** The description for the section. */ + description?: string; + /** The labels available to use as query param filter in the LIST /sections endpoint. */ + labels: string[]; + /** Shows the currently published version of this section. */ + publishedVersion?: Corti.SectionVersion; + /** The original timestamp when the section was created. */ + createdAt: Date; + /** The original timestamp when the section was last updated. */ + updatedAt: Date; +} diff --git a/src/api/types/SectionGeneration.ts b/src/api/types/SectionGeneration.ts new file mode 100644 index 00000000..7e4233b9 --- /dev/null +++ b/src/api/types/SectionGeneration.ts @@ -0,0 +1,11 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface SectionGeneration { + /** The title of this section. Passed to the LLM. */ + title: string; + /** The prompt instructions for this section. */ + instructions: Corti.SectionInstructions; + outputSchema: Corti.OutputSchema; +} diff --git a/src/api/types/SectionInstructions.ts b/src/api/types/SectionInstructions.ts new file mode 100644 index 00000000..2ce814e5 --- /dev/null +++ b/src/api/types/SectionInstructions.ts @@ -0,0 +1,10 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface SectionInstructions { + /** The content prompt instructs the model what to include for synthesis. For `documentationMode: routed_parallel` this impacts what facts to route to this section. */ + contentPrompt: string; + /** The writingStyle prompt instructs the model in what tone and style to output. */ + writingStylePrompt?: string; + /** Optional free-form prompt for any instructions that don't fit contentPrompt or writingStylePrompt. */ + miscPrompt?: string; +} diff --git a/src/api/types/SectionVersion.ts b/src/api/types/SectionVersion.ts new file mode 100644 index 00000000..fe3c6b68 --- /dev/null +++ b/src/api/types/SectionVersion.ts @@ -0,0 +1,11 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface SectionVersion { + /** The UUID of the section version. */ + id: string; + /** Starts at 0 and auto-increments. */ + versionNumber: number; + generation: Corti.SectionGeneration; +} diff --git a/src/api/types/StatusResponse.ts b/src/api/types/StatusResponse.ts new file mode 100644 index 00000000..15ca5217 --- /dev/null +++ b/src/api/types/StatusResponse.ts @@ -0,0 +1,5 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface StatusResponse { + status: string; +} diff --git a/src/api/types/StringNode.ts b/src/api/types/StringNode.ts new file mode 100644 index 00000000..5571866e --- /dev/null +++ b/src/api/types/StringNode.ts @@ -0,0 +1,13 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface StringNode { + type: "string"; + /** Can be used to prompt the LLM with more guidance in addition to the section.instructions */ + description?: string; + /** The default to output if nothing to output. */ + default?: string | null; + /** Can be used to prompt the LLM with specific values to output. */ + enum?: string[]; + /** Can be used to prompt the LLM for a specific output pattern. */ + pattern?: string | null; +} diff --git a/src/api/types/Template.ts b/src/api/types/Template.ts new file mode 100644 index 00000000..bd6525ad --- /dev/null +++ b/src/api/types/Template.ts @@ -0,0 +1,25 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface Template { + /** The UUID of the template. */ + id: string; + /** Reference to the template to inherit template instructions and sections from. Inherits from published version by default. */ + inheritedFromId?: string | null; + /** True if the template was auto-generated based on the section-composed POST /documents request. */ + autoGenerated?: boolean; + /** The name of this template. Not passed to the LLM. */ + name: string; + /** A description for this template. Not passed to the LLM. */ + description?: string; + /** The intended language as BCP 47 tag. Does not strictly have to match outputLanguage in POST /documents request. */ + language: string; + /** The available labels to use as query param filter in the LIST /templates endpoint. */ + labels: string[]; + publishedVersion?: Corti.TemplateVersion; + /** The original timestamp when the template was created. */ + createdAt: Date; + /** The original timestamp when the template was last updated. */ + updatedAt: Date; +} diff --git a/src/api/types/TemplateGeneration.ts b/src/api/types/TemplateGeneration.ts new file mode 100644 index 00000000..ab962c41 --- /dev/null +++ b/src/api/types/TemplateGeneration.ts @@ -0,0 +1,9 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface TemplateGeneration { + instructions: Corti.TemplateInstructions; + /** Populated only on GET /alpha/templates/{templateID}/versions/{versionID}; omitted from list responses. */ + sections?: Corti.Section[]; +} diff --git a/src/api/types/TemplateInstructions.ts b/src/api/types/TemplateInstructions.ts new file mode 100644 index 00000000..c72499a1 --- /dev/null +++ b/src/api/types/TemplateInstructions.ts @@ -0,0 +1,6 @@ +// This file was auto-generated by Fern from our API Definition. + +export interface TemplateInstructions { + /** Template-level prompt instructions that apply generally to all sections. */ + prompt: string; +} diff --git a/src/api/types/TemplateVersion.ts b/src/api/types/TemplateVersion.ts new file mode 100644 index 00000000..94e72fb7 --- /dev/null +++ b/src/api/types/TemplateVersion.ts @@ -0,0 +1,11 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../index.js"; + +export interface TemplateVersion { + /** The UUID of the version. */ + id: string; + /** Starts at 0 and auto-increments. */ + versionNumber: number; + generation: Corti.TemplateGeneration; +} diff --git a/src/api/types/index.ts b/src/api/types/index.ts index 66b9b853..84546e54 100644 --- a/src/api/types/index.ts +++ b/src/api/types/index.ts @@ -56,12 +56,14 @@ export * from "./AgentsUpdateExpertReference.js"; export * from "./AgentsValidationError.js"; export * from "./AgentsValidationErrorErrorsItem.js"; export * from "./AgentsValidationErrorResponse.js"; +export * from "./ArrayNode.js"; export * from "./AuthTokenRequestAuthorizationCode.js"; export * from "./AuthTokenRequestAuthorizationPkce.js"; export * from "./AuthTokenRequestClientCredentials.js"; export * from "./AuthTokenRequestRefresh.js"; export * from "./AuthTokenRequestRopc.js"; export * from "./AuthTokenResponse.js"; +export * from "./BoolNode.js"; export * from "./CodesFilter.js"; export * from "./CodesGeneralReadResponse.js"; export * from "./CodesGeneralReadResponseAlternativesItem.js"; @@ -113,6 +115,7 @@ export * from "./FactsFactGroupsListResponse.js"; export * from "./FactsListItem.js"; export * from "./FactsListResponse.js"; export * from "./FactsUpdateResponse.js"; +export * from "./FieldDefinition.js"; export * from "./InteractionsCreateResponse.js"; export * from "./InteractionsEncounterCreateRequest.js"; export * from "./InteractionsEncounterPeriod.js"; @@ -124,9 +127,17 @@ export * from "./InteractionsGenderEnum.js"; export * from "./InteractionsGetResponse.js"; export * from "./InteractionsListResponse.js"; export * from "./InteractionsPatient.js"; +export * from "./NumberNode.js"; export * from "./OAuthTokenRequest.js"; +export * from "./ObjectNode.js"; +export * from "./OutputSchema.js"; export * from "./RecordingsCreateResponse.js"; export * from "./RecordingsListResponse.js"; +export * from "./Section.js"; +export * from "./SectionGeneration.js"; +export * from "./SectionInstructions.js"; +export * from "./SectionVersion.js"; +export * from "./StatusResponse.js"; export * from "./StreamConfig.js"; export * from "./StreamConfigMessage.js"; export * from "./StreamConfigMode.js"; @@ -152,6 +163,10 @@ export * from "./StreamTranscript.js"; export * from "./StreamTranscriptMessage.js"; export * from "./StreamTranscriptTime.js"; export * from "./StreamUsageMessage.js"; +export * from "./StringNode.js"; +export * from "./Template.js"; +export * from "./TemplateGeneration.js"; +export * from "./TemplateInstructions.js"; export * from "./TemplatesDocumentationModeEnum.js"; export * from "./TemplatesFormatRule.js"; export * from "./TemplatesItem.js"; @@ -162,6 +177,7 @@ export * from "./TemplatesSectionSorted.js"; export * from "./TemplatesSectionTranslation.js"; export * from "./TemplatesTranslation.js"; export * from "./TemplatesWritingStyle.js"; +export * from "./TemplateVersion.js"; export * from "./TranscribeCommand.js"; export * from "./TranscribeCommandData.js"; export * from "./TranscribeCommandMessage.js"; diff --git a/src/serialization/resources/alphaSections/client/index.ts b/src/serialization/resources/alphaSections/client/index.ts new file mode 100644 index 00000000..195f9aa8 --- /dev/null +++ b/src/serialization/resources/alphaSections/client/index.ts @@ -0,0 +1 @@ +export * from "./requests/index.js"; diff --git a/src/serialization/resources/alphaSections/client/requests/UpdateSectionRequest.ts b/src/serialization/resources/alphaSections/client/requests/UpdateSectionRequest.ts new file mode 100644 index 00000000..2eb7957e --- /dev/null +++ b/src/serialization/resources/alphaSections/client/requests/UpdateSectionRequest.ts @@ -0,0 +1,24 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../../../../api/index.js"; +import * as core from "../../../../../core/index.js"; +import type * as serializers from "../../../../index.js"; + +export const UpdateSectionRequest: core.serialization.Schema< + serializers.UpdateSectionRequest.Raw, + Corti.UpdateSectionRequest +> = core.serialization.object({ + name: core.serialization.string().optional(), + language: core.serialization.string().optional(), + description: core.serialization.string().optional(), + labels: core.serialization.list(core.serialization.string()).optional(), +}); + +export declare namespace UpdateSectionRequest { + export interface Raw { + name?: string | null; + language?: string | null; + description?: string | null; + labels?: string[] | null; + } +} diff --git a/src/serialization/resources/alphaSections/client/requests/index.ts b/src/serialization/resources/alphaSections/client/requests/index.ts new file mode 100644 index 00000000..a36d62ad --- /dev/null +++ b/src/serialization/resources/alphaSections/client/requests/index.ts @@ -0,0 +1 @@ +export { UpdateSectionRequest } from "./UpdateSectionRequest.js"; diff --git a/src/serialization/resources/alphaSections/index.ts b/src/serialization/resources/alphaSections/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/serialization/resources/alphaSections/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/serialization/resources/alphaTemplates/client/index.ts b/src/serialization/resources/alphaTemplates/client/index.ts new file mode 100644 index 00000000..195f9aa8 --- /dev/null +++ b/src/serialization/resources/alphaTemplates/client/index.ts @@ -0,0 +1 @@ +export * from "./requests/index.js"; diff --git a/src/serialization/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts b/src/serialization/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts new file mode 100644 index 00000000..a4d65a3a --- /dev/null +++ b/src/serialization/resources/alphaTemplates/client/requests/UpdateTemplateRequest.ts @@ -0,0 +1,24 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../../../../api/index.js"; +import * as core from "../../../../../core/index.js"; +import type * as serializers from "../../../../index.js"; + +export const UpdateTemplateRequest: core.serialization.Schema< + serializers.UpdateTemplateRequest.Raw, + Corti.UpdateTemplateRequest +> = core.serialization.object({ + name: core.serialization.string().optional(), + description: core.serialization.string().optional(), + language: core.serialization.string().optional(), + labels: core.serialization.list(core.serialization.string()).optional(), +}); + +export declare namespace UpdateTemplateRequest { + export interface Raw { + name?: string | null; + description?: string | null; + language?: string | null; + labels?: string[] | null; + } +} diff --git a/src/serialization/resources/alphaTemplates/client/requests/index.ts b/src/serialization/resources/alphaTemplates/client/requests/index.ts new file mode 100644 index 00000000..aa555e1b --- /dev/null +++ b/src/serialization/resources/alphaTemplates/client/requests/index.ts @@ -0,0 +1 @@ +export { UpdateTemplateRequest } from "./UpdateTemplateRequest.js"; diff --git a/src/serialization/resources/alphaTemplates/index.ts b/src/serialization/resources/alphaTemplates/index.ts new file mode 100644 index 00000000..914b8c3c --- /dev/null +++ b/src/serialization/resources/alphaTemplates/index.ts @@ -0,0 +1 @@ +export * from "./client/index.js"; diff --git a/src/serialization/resources/index.ts b/src/serialization/resources/index.ts index 58cf7e90..6d068f65 100644 --- a/src/serialization/resources/index.ts +++ b/src/serialization/resources/index.ts @@ -1,6 +1,10 @@ export * from "./agents/client/requests/index.js"; export * as agents from "./agents/index.js"; export * from "./agents/types/index.js"; +export * from "./alphaSections/client/requests/index.js"; +export * as alphaSections from "./alphaSections/index.js"; +export * from "./alphaTemplates/client/requests/index.js"; +export * as alphaTemplates from "./alphaTemplates/index.js"; export * as auth from "./auth/index.js"; export * from "./auth/types/index.js"; export * from "./codes/client/requests/index.js"; diff --git a/src/serialization/types/AgentsCreateExpertReference.ts b/src/serialization/types/AgentsCreateExpertReference.ts index 535bdd16..db40af90 100644 --- a/src/serialization/types/AgentsCreateExpertReference.ts +++ b/src/serialization/types/AgentsCreateExpertReference.ts @@ -13,6 +13,7 @@ export const AgentsCreateExpertReference: core.serialization.ObjectSchema< id: core.serialization.string().optional(), name: core.serialization.string().optional(), systemPrompt: core.serialization.string().optional(), + config: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(), }); export declare namespace AgentsCreateExpertReference { @@ -21,5 +22,6 @@ export declare namespace AgentsCreateExpertReference { id?: string | null; name?: string | null; systemPrompt?: string | null; + config?: Record | null; } } diff --git a/src/serialization/types/AgentsExpertReference.ts b/src/serialization/types/AgentsExpertReference.ts index 1dbdbf71..00a6167b 100644 --- a/src/serialization/types/AgentsExpertReference.ts +++ b/src/serialization/types/AgentsExpertReference.ts @@ -13,6 +13,7 @@ export const AgentsExpertReference: core.serialization.ObjectSchema< id: core.serialization.string(), name: core.serialization.string(), systemPrompt: core.serialization.string().optional(), + resolvedConfig: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(), }); export declare namespace AgentsExpertReference { @@ -21,5 +22,6 @@ export declare namespace AgentsExpertReference { id: string; name: string; systemPrompt?: string | null; + resolvedConfig?: Record | null; } } diff --git a/src/serialization/types/AgentsRegistryExpert.ts b/src/serialization/types/AgentsRegistryExpert.ts index c29b3a23..674c9ced 100644 --- a/src/serialization/types/AgentsRegistryExpert.ts +++ b/src/serialization/types/AgentsRegistryExpert.ts @@ -14,6 +14,7 @@ export const AgentsRegistryExpert: core.serialization.ObjectSchema< displayDescription: core.serialization.string().optional(), description: core.serialization.string(), mcpServers: core.serialization.list(AgentsRegistryMcpServer).optional(), + configSchema: core.serialization.record(core.serialization.string(), core.serialization.unknown()).optional(), }); export declare namespace AgentsRegistryExpert { @@ -23,5 +24,6 @@ export declare namespace AgentsRegistryExpert { displayDescription?: string | null; description: string; mcpServers?: AgentsRegistryMcpServer.Raw[] | null; + configSchema?: Record | null; } } diff --git a/src/serialization/types/ArrayNode.ts b/src/serialization/types/ArrayNode.ts new file mode 100644 index 00000000..363d8b79 --- /dev/null +++ b/src/serialization/types/ArrayNode.ts @@ -0,0 +1,26 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import * as serializers from "../index.js"; + +export const ArrayNode: core.serialization.ObjectSchema = + core.serialization.object({ + type: core.serialization.stringLiteral("array"), + description: core.serialization.string().optional(), + items: core.serialization.lazy(() => serializers.OutputSchema), + itemFormat: core.serialization.string().optional(), + minItems: core.serialization.number().optionalNullable(), + maxItems: core.serialization.number().optionalNullable(), + }); + +export declare namespace ArrayNode { + export interface Raw { + type: "array"; + description?: string | null; + items: serializers.OutputSchema.Raw; + itemFormat?: string | null; + minItems?: (number | null | undefined) | null; + maxItems?: (number | null | undefined) | null; + } +} diff --git a/src/serialization/types/BoolNode.ts b/src/serialization/types/BoolNode.ts new file mode 100644 index 00000000..38a73c89 --- /dev/null +++ b/src/serialization/types/BoolNode.ts @@ -0,0 +1,20 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const BoolNode: core.serialization.ObjectSchema = + core.serialization.object({ + type: core.serialization.stringLiteral("boolean"), + description: core.serialization.string().optional(), + default: core.serialization.boolean().optionalNullable(), + }); + +export declare namespace BoolNode { + export interface Raw { + type: "boolean"; + description?: string | null; + default?: (boolean | null | undefined) | null; + } +} diff --git a/src/serialization/types/FieldDefinition.ts b/src/serialization/types/FieldDefinition.ts new file mode 100644 index 00000000..169d1073 --- /dev/null +++ b/src/serialization/types/FieldDefinition.ts @@ -0,0 +1,20 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import * as serializers from "../index.js"; + +export const FieldDefinition: core.serialization.ObjectSchema = + core.serialization.object({ + key: core.serialization.string(), + description: core.serialization.string(), + value: core.serialization.lazy(() => serializers.OutputSchema), + }); + +export declare namespace FieldDefinition { + export interface Raw { + key: string; + description: string; + value: serializers.OutputSchema.Raw; + } +} diff --git a/src/serialization/types/NumberNode.ts b/src/serialization/types/NumberNode.ts new file mode 100644 index 00000000..10474663 --- /dev/null +++ b/src/serialization/types/NumberNode.ts @@ -0,0 +1,26 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const NumberNode: core.serialization.ObjectSchema = + core.serialization.object({ + type: core.serialization.stringLiteral("number"), + description: core.serialization.string().optional(), + default: core.serialization.number().optionalNullable(), + enum: core.serialization.list(core.serialization.number()).optional(), + minimum: core.serialization.number().optionalNullable(), + maximum: core.serialization.number().optionalNullable(), + }); + +export declare namespace NumberNode { + export interface Raw { + type: "number"; + description?: string | null; + default?: (number | null | undefined) | null; + enum?: number[] | null; + minimum?: (number | null | undefined) | null; + maximum?: (number | null | undefined) | null; + } +} diff --git a/src/serialization/types/ObjectNode.ts b/src/serialization/types/ObjectNode.ts new file mode 100644 index 00000000..ee8a6e62 --- /dev/null +++ b/src/serialization/types/ObjectNode.ts @@ -0,0 +1,24 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import * as serializers from "../index.js"; + +export const ObjectNode: core.serialization.ObjectSchema = + core.serialization.object({ + type: core.serialization.stringLiteral("object"), + description: core.serialization.string().optional(), + subheadingFormat: core.serialization.string().optional(), + objectFormat: core.serialization.string().optional(), + fields: core.serialization.list(core.serialization.lazyObject(() => serializers.FieldDefinition)).optional(), + }); + +export declare namespace ObjectNode { + export interface Raw { + type: "object"; + description?: string | null; + subheadingFormat?: string | null; + objectFormat?: string | null; + fields?: serializers.FieldDefinition.Raw[] | null; + } +} diff --git a/src/serialization/types/OutputSchema.ts b/src/serialization/types/OutputSchema.ts new file mode 100644 index 00000000..02f2e117 --- /dev/null +++ b/src/serialization/types/OutputSchema.ts @@ -0,0 +1,26 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import * as serializers from "../index.js"; +import { BoolNode } from "./BoolNode.js"; +import { NumberNode } from "./NumberNode.js"; +import { StringNode } from "./StringNode.js"; + +export const OutputSchema: core.serialization.Schema = + core.serialization.undiscriminatedUnion([ + StringNode, + NumberNode, + BoolNode, + core.serialization.lazyObject(() => serializers.ObjectNode), + core.serialization.lazyObject(() => serializers.ArrayNode), + ]); + +export declare namespace OutputSchema { + export type Raw = + | StringNode.Raw + | NumberNode.Raw + | BoolNode.Raw + | serializers.ObjectNode.Raw + | serializers.ArrayNode.Raw; +} diff --git a/src/serialization/types/Section.ts b/src/serialization/types/Section.ts new file mode 100644 index 00000000..fe070ce9 --- /dev/null +++ b/src/serialization/types/Section.ts @@ -0,0 +1,35 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; +import { SectionVersion } from "./SectionVersion.js"; + +export const Section: core.serialization.ObjectSchema = + core.serialization.object({ + id: core.serialization.string(), + inheritedFromId: core.serialization.string().optionalNullable(), + autoGenerated: core.serialization.boolean().optional(), + name: core.serialization.string(), + language: core.serialization.string(), + description: core.serialization.string().optional(), + labels: core.serialization.list(core.serialization.string()), + publishedVersion: SectionVersion.optional(), + createdAt: core.serialization.date(), + updatedAt: core.serialization.date(), + }); + +export declare namespace Section { + export interface Raw { + id: string; + inheritedFromId?: (string | null | undefined) | null; + autoGenerated?: boolean | null; + name: string; + language: string; + description?: string | null; + labels: string[]; + publishedVersion?: SectionVersion.Raw | null; + createdAt: string; + updatedAt: string; + } +} diff --git a/src/serialization/types/SectionGeneration.ts b/src/serialization/types/SectionGeneration.ts new file mode 100644 index 00000000..d72905d4 --- /dev/null +++ b/src/serialization/types/SectionGeneration.ts @@ -0,0 +1,23 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import * as serializers from "../index.js"; +import { SectionInstructions } from "./SectionInstructions.js"; + +export const SectionGeneration: core.serialization.ObjectSchema< + serializers.SectionGeneration.Raw, + Corti.SectionGeneration +> = core.serialization.object({ + title: core.serialization.string(), + instructions: SectionInstructions, + outputSchema: core.serialization.lazy(() => serializers.OutputSchema), +}); + +export declare namespace SectionGeneration { + export interface Raw { + title: string; + instructions: SectionInstructions.Raw; + outputSchema: serializers.OutputSchema.Raw; + } +} diff --git a/src/serialization/types/SectionInstructions.ts b/src/serialization/types/SectionInstructions.ts new file mode 100644 index 00000000..a1e097a4 --- /dev/null +++ b/src/serialization/types/SectionInstructions.ts @@ -0,0 +1,22 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const SectionInstructions: core.serialization.ObjectSchema< + serializers.SectionInstructions.Raw, + Corti.SectionInstructions +> = core.serialization.object({ + contentPrompt: core.serialization.string(), + writingStylePrompt: core.serialization.string().optional(), + miscPrompt: core.serialization.string().optional(), +}); + +export declare namespace SectionInstructions { + export interface Raw { + contentPrompt: string; + writingStylePrompt?: string | null; + miscPrompt?: string | null; + } +} diff --git a/src/serialization/types/SectionVersion.ts b/src/serialization/types/SectionVersion.ts new file mode 100644 index 00000000..8809bb35 --- /dev/null +++ b/src/serialization/types/SectionVersion.ts @@ -0,0 +1,21 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; +import { SectionGeneration } from "./SectionGeneration.js"; + +export const SectionVersion: core.serialization.ObjectSchema = + core.serialization.object({ + id: core.serialization.string(), + versionNumber: core.serialization.number(), + generation: SectionGeneration, + }); + +export declare namespace SectionVersion { + export interface Raw { + id: string; + versionNumber: number; + generation: SectionGeneration.Raw; + } +} diff --git a/src/serialization/types/StatusResponse.ts b/src/serialization/types/StatusResponse.ts new file mode 100644 index 00000000..e3d3dbe6 --- /dev/null +++ b/src/serialization/types/StatusResponse.ts @@ -0,0 +1,16 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const StatusResponse: core.serialization.ObjectSchema = + core.serialization.object({ + status: core.serialization.string(), + }); + +export declare namespace StatusResponse { + export interface Raw { + status: string; + } +} diff --git a/src/serialization/types/StringNode.ts b/src/serialization/types/StringNode.ts new file mode 100644 index 00000000..3bd5d85a --- /dev/null +++ b/src/serialization/types/StringNode.ts @@ -0,0 +1,24 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const StringNode: core.serialization.ObjectSchema = + core.serialization.object({ + type: core.serialization.stringLiteral("string"), + description: core.serialization.string().optional(), + default: core.serialization.string().optionalNullable(), + enum: core.serialization.list(core.serialization.string()).optional(), + pattern: core.serialization.string().optionalNullable(), + }); + +export declare namespace StringNode { + export interface Raw { + type: "string"; + description?: string | null; + default?: (string | null | undefined) | null; + enum?: string[] | null; + pattern?: (string | null | undefined) | null; + } +} diff --git a/src/serialization/types/Template.ts b/src/serialization/types/Template.ts new file mode 100644 index 00000000..b3814a1a --- /dev/null +++ b/src/serialization/types/Template.ts @@ -0,0 +1,35 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; +import { TemplateVersion } from "./TemplateVersion.js"; + +export const Template: core.serialization.ObjectSchema = + core.serialization.object({ + id: core.serialization.string(), + inheritedFromId: core.serialization.string().optionalNullable(), + autoGenerated: core.serialization.boolean().optional(), + name: core.serialization.string(), + description: core.serialization.string().optional(), + language: core.serialization.string(), + labels: core.serialization.list(core.serialization.string()), + publishedVersion: TemplateVersion.optional(), + createdAt: core.serialization.date(), + updatedAt: core.serialization.date(), + }); + +export declare namespace Template { + export interface Raw { + id: string; + inheritedFromId?: (string | null | undefined) | null; + autoGenerated?: boolean | null; + name: string; + description?: string | null; + language: string; + labels: string[]; + publishedVersion?: TemplateVersion.Raw | null; + createdAt: string; + updatedAt: string; + } +} diff --git a/src/serialization/types/TemplateGeneration.ts b/src/serialization/types/TemplateGeneration.ts new file mode 100644 index 00000000..d7d02886 --- /dev/null +++ b/src/serialization/types/TemplateGeneration.ts @@ -0,0 +1,22 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; +import { Section } from "./Section.js"; +import { TemplateInstructions } from "./TemplateInstructions.js"; + +export const TemplateGeneration: core.serialization.ObjectSchema< + serializers.TemplateGeneration.Raw, + Corti.TemplateGeneration +> = core.serialization.object({ + instructions: TemplateInstructions, + sections: core.serialization.list(Section).optional(), +}); + +export declare namespace TemplateGeneration { + export interface Raw { + instructions: TemplateInstructions.Raw; + sections?: Section.Raw[] | null; + } +} diff --git a/src/serialization/types/TemplateInstructions.ts b/src/serialization/types/TemplateInstructions.ts new file mode 100644 index 00000000..ac302df9 --- /dev/null +++ b/src/serialization/types/TemplateInstructions.ts @@ -0,0 +1,18 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; + +export const TemplateInstructions: core.serialization.ObjectSchema< + serializers.TemplateInstructions.Raw, + Corti.TemplateInstructions +> = core.serialization.object({ + prompt: core.serialization.string(), +}); + +export declare namespace TemplateInstructions { + export interface Raw { + prompt: string; + } +} diff --git a/src/serialization/types/TemplateVersion.ts b/src/serialization/types/TemplateVersion.ts new file mode 100644 index 00000000..cabcb3cd --- /dev/null +++ b/src/serialization/types/TemplateVersion.ts @@ -0,0 +1,21 @@ +// This file was auto-generated by Fern from our API Definition. + +import type * as Corti from "../../api/index.js"; +import * as core from "../../core/index.js"; +import type * as serializers from "../index.js"; +import { TemplateGeneration } from "./TemplateGeneration.js"; + +export const TemplateVersion: core.serialization.ObjectSchema = + core.serialization.object({ + id: core.serialization.string(), + versionNumber: core.serialization.number(), + generation: TemplateGeneration, + }); + +export declare namespace TemplateVersion { + export interface Raw { + id: string; + versionNumber: number; + generation: TemplateGeneration.Raw; + } +} diff --git a/src/serialization/types/index.ts b/src/serialization/types/index.ts index 66b9b853..84546e54 100644 --- a/src/serialization/types/index.ts +++ b/src/serialization/types/index.ts @@ -56,12 +56,14 @@ export * from "./AgentsUpdateExpertReference.js"; export * from "./AgentsValidationError.js"; export * from "./AgentsValidationErrorErrorsItem.js"; export * from "./AgentsValidationErrorResponse.js"; +export * from "./ArrayNode.js"; export * from "./AuthTokenRequestAuthorizationCode.js"; export * from "./AuthTokenRequestAuthorizationPkce.js"; export * from "./AuthTokenRequestClientCredentials.js"; export * from "./AuthTokenRequestRefresh.js"; export * from "./AuthTokenRequestRopc.js"; export * from "./AuthTokenResponse.js"; +export * from "./BoolNode.js"; export * from "./CodesFilter.js"; export * from "./CodesGeneralReadResponse.js"; export * from "./CodesGeneralReadResponseAlternativesItem.js"; @@ -113,6 +115,7 @@ export * from "./FactsFactGroupsListResponse.js"; export * from "./FactsListItem.js"; export * from "./FactsListResponse.js"; export * from "./FactsUpdateResponse.js"; +export * from "./FieldDefinition.js"; export * from "./InteractionsCreateResponse.js"; export * from "./InteractionsEncounterCreateRequest.js"; export * from "./InteractionsEncounterPeriod.js"; @@ -124,9 +127,17 @@ export * from "./InteractionsGenderEnum.js"; export * from "./InteractionsGetResponse.js"; export * from "./InteractionsListResponse.js"; export * from "./InteractionsPatient.js"; +export * from "./NumberNode.js"; export * from "./OAuthTokenRequest.js"; +export * from "./ObjectNode.js"; +export * from "./OutputSchema.js"; export * from "./RecordingsCreateResponse.js"; export * from "./RecordingsListResponse.js"; +export * from "./Section.js"; +export * from "./SectionGeneration.js"; +export * from "./SectionInstructions.js"; +export * from "./SectionVersion.js"; +export * from "./StatusResponse.js"; export * from "./StreamConfig.js"; export * from "./StreamConfigMessage.js"; export * from "./StreamConfigMode.js"; @@ -152,6 +163,10 @@ export * from "./StreamTranscript.js"; export * from "./StreamTranscriptMessage.js"; export * from "./StreamTranscriptTime.js"; export * from "./StreamUsageMessage.js"; +export * from "./StringNode.js"; +export * from "./Template.js"; +export * from "./TemplateGeneration.js"; +export * from "./TemplateInstructions.js"; export * from "./TemplatesDocumentationModeEnum.js"; export * from "./TemplatesFormatRule.js"; export * from "./TemplatesItem.js"; @@ -162,6 +177,7 @@ export * from "./TemplatesSectionSorted.js"; export * from "./TemplatesSectionTranslation.js"; export * from "./TemplatesTranslation.js"; export * from "./TemplatesWritingStyle.js"; +export * from "./TemplateVersion.js"; export * from "./TranscribeCommand.js"; export * from "./TranscribeCommandData.js"; export * from "./TranscribeCommandMessage.js"; diff --git a/tests/wire/agents.test.ts b/tests/wire/agents.test.ts index acd362e9..4cc9e418 100644 --- a/tests/wire/agents.test.ts +++ b/tests/wire/agents.test.ts @@ -1793,6 +1793,7 @@ describe("AgentsClient", () => { displayDescription: "displayDescription", description: "description", mcpServers: [{ name: "name", authorizationType: "none" }], + configSchema: { key: "value" }, }, ], }; @@ -1822,6 +1823,9 @@ describe("AgentsClient", () => { authorizationType: "none", }, ], + configSchema: { + key: "value", + }, }, ], }); diff --git a/tests/wire/alphaSectionVersions.test.ts b/tests/wire/alphaSectionVersions.test.ts new file mode 100644 index 00000000..851ebf85 --- /dev/null +++ b/tests/wire/alphaSectionVersions.test.ts @@ -0,0 +1,238 @@ +// This file was auto-generated by Fern from our API Definition. + +import * as Corti from "../../src/api/index"; +import { CortiClient } from "../../src/Client"; +import { mockServerPool } from "../mock-server/MockServerPool"; +import { mockOAuth } from "./mockAuth"; + +describe("AlphaSectionVersionsClient", () => { + test("get (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + writingStylePrompt: "writingStylePrompt", + miscPrompt: "miscPrompt", + }, + outputSchema: { + type: "string", + description: "description", + default: "default", + enum: ["enum"], + pattern: "pattern", + }, + }, + }; + + server + .mockEndpoint() + .get("/alpha/sections/sectionID/versions/versionID") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaSectionVersions.get("sectionID", "versionID"); + expect(response).toEqual({ + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + writingStylePrompt: "writingStylePrompt", + miscPrompt: "miscPrompt", + }, + outputSchema: { + type: "string", + description: "description", + default: "default", + enum: ["enum"], + pattern: "pattern", + }, + }, + }); + }); + + test("get (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .get("/alpha/sections/sectionID/versions/versionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSectionVersions.get("sectionID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("delete (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server + .mockEndpoint() + .delete("/alpha/sections/sectionID/versions/versionID") + .respondWith() + .statusCode(200) + .build(); + + const response = await client.alphaSectionVersions.delete("sectionID", "versionID"); + expect(response).toEqual(undefined); + }); + + test("delete (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .delete("/alpha/sections/sectionID/versions/versionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSectionVersions.delete("sectionID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("publish (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { status: "published" }; + + server + .mockEndpoint() + .post("/alpha/sections/sectionID/versions/versionID/publish") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaSectionVersions.publish("sectionID", "versionID"); + expect(response).toEqual({ + status: "published", + }); + }); + + test("publish (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .post("/alpha/sections/sectionID/versions/versionID/publish") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSectionVersions.publish("sectionID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("list", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().get("/alpha/sections/sectionID/versions").respondWith().statusCode(200).build(); + + const response = await client.alphaSectionVersions.list("sectionID"); + expect(response).toEqual(undefined); + }); + + test("create", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().post("/alpha/sections/sectionID/versions").respondWith().statusCode(200).build(); + + const response = await client.alphaSectionVersions.create("sectionID"); + expect(response).toEqual(undefined); + }); +}); diff --git a/tests/wire/alphaSections.test.ts b/tests/wire/alphaSections.test.ts new file mode 100644 index 00000000..ec08e8db --- /dev/null +++ b/tests/wire/alphaSections.test.ts @@ -0,0 +1,309 @@ +// This file was auto-generated by Fern from our API Definition. + +import * as Corti from "../../src/api/index"; +import { CortiClient } from "../../src/Client"; +import { mockServerPool } from "../mock-server/MockServerPool"; +import { mockOAuth } from "./mockAuth"; + +describe("AlphaSectionsClient", () => { + test("get (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + language: "language", + description: "description", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { contentPrompt: "contentPrompt" }, + outputSchema: { type: "string" }, + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }; + + server + .mockEndpoint() + .get("/alpha/sections/sectionID") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaSections.get("sectionID"); + expect(response).toEqual({ + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + language: "language", + description: "description", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + }, + outputSchema: { + type: "string", + }, + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }); + }); + + test("get (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .get("/alpha/sections/sectionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSections.get("sectionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("delete (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().delete("/alpha/sections/sectionID").respondWith().statusCode(200).build(); + + const response = await client.alphaSections.delete("sectionID"); + expect(response).toEqual(undefined); + }); + + test("delete (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .delete("/alpha/sections/sectionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSections.delete("sectionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("update (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + language: "language", + description: "description", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { contentPrompt: "contentPrompt" }, + outputSchema: { type: "string" }, + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }; + + server + .mockEndpoint() + .patch("/alpha/sections/sectionID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaSections.update("sectionID"); + expect(response).toEqual({ + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + language: "language", + description: "description", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + }, + outputSchema: { + type: "string", + }, + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }); + }); + + test("update (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .patch("/alpha/sections/sectionID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(400) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSections.update("sectionID"); + }).rejects.toThrow(Corti.BadRequestError); + }); + + test("update (3)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .patch("/alpha/sections/sectionID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaSections.update("sectionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("list", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().get("/alpha/sections").respondWith().statusCode(200).build(); + + const response = await client.alphaSections.list(); + expect(response).toEqual(undefined); + }); + + test("create", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().post("/alpha/sections").respondWith().statusCode(200).build(); + + const response = await client.alphaSections.create(); + expect(response).toEqual(undefined); + }); +}); diff --git a/tests/wire/alphaTemplateVersions.test.ts b/tests/wire/alphaTemplateVersions.test.ts new file mode 100644 index 00000000..0693fa3f --- /dev/null +++ b/tests/wire/alphaTemplateVersions.test.ts @@ -0,0 +1,258 @@ +// This file was auto-generated by Fern from our API Definition. + +import * as Corti from "../../src/api/index"; +import { CortiClient } from "../../src/Client"; +import { mockServerPool } from "../mock-server/MockServerPool"; +import { mockOAuth } from "./mockAuth"; + +describe("AlphaTemplateVersionsClient", () => { + test("get (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { + id: "id", + versionNumber: 1, + generation: { + instructions: { prompt: "prompt" }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { contentPrompt: "contentPrompt" }, + outputSchema: { type: "string" }, + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }, + ], + }, + }; + + server + .mockEndpoint() + .get("/alpha/templates/templateID/versions/versionID") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaTemplateVersions.get("templateID", "versionID"); + expect(response).toEqual({ + id: "id", + versionNumber: 1, + generation: { + instructions: { + prompt: "prompt", + }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + }, + outputSchema: { + type: "string", + }, + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }, + ], + }, + }); + }); + + test("get (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .get("/alpha/templates/templateID/versions/versionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplateVersions.get("templateID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("delete (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server + .mockEndpoint() + .delete("/alpha/templates/templateID/versions/versionID") + .respondWith() + .statusCode(200) + .build(); + + const response = await client.alphaTemplateVersions.delete("templateID", "versionID"); + expect(response).toEqual(undefined); + }); + + test("delete (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .delete("/alpha/templates/templateID/versions/versionID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplateVersions.delete("templateID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("publish (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { status: "published" }; + + server + .mockEndpoint() + .post("/alpha/templates/templateID/versions/versionID/publish") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaTemplateVersions.publish("templateID", "versionID"); + expect(response).toEqual({ + status: "published", + }); + }); + + test("publish (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .post("/alpha/templates/templateID/versions/versionID/publish") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplateVersions.publish("templateID", "versionID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("list", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().get("/alpha/templates/templateID/versions").respondWith().statusCode(200).build(); + + const response = await client.alphaTemplateVersions.list("templateID"); + expect(response).toEqual(undefined); + }); + + test("create", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().post("/alpha/templates/templateID/versions").respondWith().statusCode(200).build(); + + const response = await client.alphaTemplateVersions.create("templateID"); + expect(response).toEqual(undefined); + }); +}); diff --git a/tests/wire/alphaTemplates.test.ts b/tests/wire/alphaTemplates.test.ts new file mode 100644 index 00000000..629d0a28 --- /dev/null +++ b/tests/wire/alphaTemplates.test.ts @@ -0,0 +1,381 @@ +// This file was auto-generated by Fern from our API Definition. + +import * as Corti from "../../src/api/index"; +import { CortiClient } from "../../src/Client"; +import { mockServerPool } from "../mock-server/MockServerPool"; +import { mockOAuth } from "./mockAuth"; + +describe("AlphaTemplatesClient", () => { + test("get (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + description: "description", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + instructions: { prompt: "prompt" }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { contentPrompt: "contentPrompt" }, + outputSchema: { type: "string" }, + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }, + ], + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }; + + server + .mockEndpoint() + .get("/alpha/templates/templateID") + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaTemplates.get("templateID"); + expect(response).toEqual({ + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + description: "description", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + instructions: { + prompt: "prompt", + }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + }, + outputSchema: { + type: "string", + }, + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }, + ], + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }); + }); + + test("get (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .get("/alpha/templates/templateID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplates.get("templateID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("delete (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().delete("/alpha/templates/templateID").respondWith().statusCode(200).build(); + + const response = await client.alphaTemplates.delete("templateID"); + expect(response).toEqual(undefined); + }); + + test("delete (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .delete("/alpha/templates/templateID") + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplates.delete("templateID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("update (1)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + description: "description", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + instructions: { prompt: "prompt" }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { contentPrompt: "contentPrompt" }, + outputSchema: { type: "string" }, + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }, + ], + }, + }, + createdAt: "2024-01-15T09:30:00Z", + updatedAt: "2024-01-15T09:30:00Z", + }; + + server + .mockEndpoint() + .patch("/alpha/templates/templateID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(200) + .jsonBody(rawResponseBody) + .build(); + + const response = await client.alphaTemplates.update("templateID"); + expect(response).toEqual({ + id: "id", + inheritedFromId: "inheritedFromId", + autoGenerated: true, + name: "name", + description: "description", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + instructions: { + prompt: "prompt", + }, + sections: [ + { + id: "id", + name: "name", + language: "language", + labels: ["labels"], + publishedVersion: { + id: "id", + versionNumber: 1, + generation: { + title: "title", + instructions: { + contentPrompt: "contentPrompt", + }, + outputSchema: { + type: "string", + }, + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }, + ], + }, + }, + createdAt: new Date("2024-01-15T09:30:00.000Z"), + updatedAt: new Date("2024-01-15T09:30:00.000Z"), + }); + }); + + test("update (2)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .patch("/alpha/templates/templateID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(400) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplates.update("templateID"); + }).rejects.toThrow(Corti.BadRequestError); + }); + + test("update (3)", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + const rawRequestBody = {}; + const rawResponseBody = { key: "value" }; + + server + .mockEndpoint() + .patch("/alpha/templates/templateID") + .jsonBody(rawRequestBody) + .respondWith() + .statusCode(404) + .jsonBody(rawResponseBody) + .build(); + + await expect(async () => { + return await client.alphaTemplates.update("templateID"); + }).rejects.toThrow(Corti.NotFoundError); + }); + + test("list", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().get("/alpha/templates").respondWith().statusCode(200).build(); + + const response = await client.alphaTemplates.list(); + expect(response).toEqual(undefined); + }); + + test("create", async () => { + const server = mockServerPool.createServer(); + mockOAuth(server); + + const client = new CortiClient({ + maxRetries: 0, + clientId: "client_id", + clientSecret: "client_secret", + tenantName: "test", + environment: { base: server.baseUrl, wss: server.baseUrl, login: server.baseUrl, agents: server.baseUrl }, + }); + + server.mockEndpoint().post("/alpha/templates").respondWith().statusCode(200).build(); + + const response = await client.alphaTemplates.create(); + expect(response).toEqual(undefined); + }); +});