@ichos/sdk 1.0.2 → 1.0.4

package/src/api/resources/podcasts/client/Client.ts

@@ -0,0 +1,1212 @@
+// 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 * as environments from "../../../../environments.js";
+import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.js";
+import * as errors from "../../../../errors/index.js";
+import * as Ichos from "../../../index.js";
+
+export declare namespace PodcastsClient {
+    export type Options = BaseClientOptions;
+
+    export interface RequestOptions extends BaseRequestOptions {}
+}
+
+export class PodcastsClient {
+    protected readonly _options: NormalizedClientOptionsWithAuth<PodcastsClient.Options>;
+
+    constructor(options: PodcastsClient.Options) {
+        this._options = normalizeClientOptionsWithAuth(options);
+    }
+
+    /**
+     * Retrieve all podcasts associated with a virtual user.
+     *
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.listUserPodcasts()
+     */
+    public listUserPodcasts(
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.PodcastsResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__listUserPodcasts(requestOptions));
+    }
+
+    private async __listUserPodcasts(
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.PodcastsResponse>> {
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                "v1/podcasts",
+            ),
+            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: _response.body as Ichos.PodcastsResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/podcasts");
+    }
+
+    /**
+     * Create a new podcast.
+     *
+     * @param {Ichos.PodcastCreate} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.createPodcast({
+     *         title: "The Tech Wave",
+     *         explicit: false
+     *     })
+     */
+    public createPodcast(
+        request: Ichos.PodcastCreate,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.PodcastResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__createPodcast(request, requestOptions));
+    }
+
+    private async __createPodcast(
+        request: Ichos.PodcastCreate,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.PodcastResponse>> {
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                "v1/podcasts",
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: request,
+            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: _response.body as Ichos.PodcastResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/podcasts");
+    }
+
+    /**
+     * Import a podcast from an RSS feed URL.
+     *
+     * @param {Ichos.ImportPodcastFromRssRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.importPodcastFromRss({
+     *         url: "url"
+     *     })
+     */
+    public importPodcastFromRss(
+        request: Ichos.ImportPodcastFromRssRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.NullResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__importPodcastFromRss(request, requestOptions));
+    }
+
+    private async __importPodcastFromRss(
+        request: Ichos.ImportPodcastFromRssRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.NullResponse>> {
+        const { url } = request;
+        const _queryParams: Record<string, string | string[] | object | object[] | null> = {};
+        _queryParams.url = url;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                "v1/podcasts/import",
+            ),
+            method: "POST",
+            headers: _headers,
+            queryParameters: { ..._queryParams, ...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: _response.body as Ichos.NullResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/v1/podcasts/import");
+    }
+
+    /**
+     * Generate a signed URL for uploading a podcast cover image.
+     *
+     * @param {Ichos.GeneratePodcastCoverUploadUrlRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.generatePodcastCoverUploadUrl({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public generatePodcastCoverUploadUrl(
+        request: Ichos.GeneratePodcastCoverUploadUrlRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.UserUploadCoverResultResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__generatePodcastCoverUploadUrl(request, requestOptions));
+    }
+
+    private async __generatePodcastCoverUploadUrl(
+        request: Ichos.GeneratePodcastCoverUploadUrlRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.UserUploadCoverResultResponse>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/cover/put`,
+            ),
+            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: _response.body as Ichos.UserUploadCoverResultResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/v1/podcasts/{podcastId}/cover/put",
+        );
+    }
+
+    /**
+     * Trigger the system to pull a podcast cover image from a URL.
+     *
+     * @param {Ichos.PullPodcastCoverFromUrlRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.pullPodcastCoverFromUrl({
+     *         podcastId: "podcastId",
+     *         url: "url"
+     *     })
+     */
+    public pullPodcastCoverFromUrl(
+        request: Ichos.PullPodcastCoverFromUrlRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.NullResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__pullPodcastCoverFromUrl(request, requestOptions));
+    }
+
+    private async __pullPodcastCoverFromUrl(
+        request: Ichos.PullPodcastCoverFromUrlRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.NullResponse>> {
+        const { podcastId, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/cover/pull`,
+            ),
+            method: "POST",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            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: _response.body as Ichos.NullResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/v1/podcasts/{podcastId}/cover/pull",
+        );
+    }
+
+    /**
+     * Retrieve the current cover image URL for a podcast.
+     *
+     * @param {Ichos.GetPodcastCoverRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.getPodcastCover({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public getPodcastCover(
+        request: Ichos.GetPodcastCoverRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.StringOrNullResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__getPodcastCover(request, requestOptions));
+    }
+
+    private async __getPodcastCover(
+        request: Ichos.GetPodcastCoverRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.StringOrNullResponse>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/cover`,
+            ),
+            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: _response.body as Ichos.StringOrNullResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/v1/podcasts/{podcastId}/cover",
+        );
+    }
+
+    /**
+     * Retrieve a single podcast by ID.
+     *
+     * @param {Ichos.GetPodcastRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.getPodcast({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public getPodcast(
+        request: Ichos.GetPodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.PodcastResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__getPodcast(request, requestOptions));
+    }
+
+    private async __getPodcast(
+        request: Ichos.GetPodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.PodcastResponse>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}`,
+            ),
+            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: _response.body as Ichos.PodcastResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/podcasts/{podcastId}");
+    }
+
+    /**
+     * Delete a podcast.
+     *
+     * @param {Ichos.DeletePodcastRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.deletePodcast({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public deletePodcast(
+        request: Ichos.DeletePodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.NullResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__deletePodcast(request, requestOptions));
+    }
+
+    private async __deletePodcast(
+        request: Ichos.DeletePodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.NullResponse>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}`,
+            ),
+            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: _response.body as Ichos.NullResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/v1/podcasts/{podcastId}");
+    }
+
+    /**
+     * Update podcast details.
+     *
+     * @param {Ichos.PodcastUpdate} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.updatePodcast({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public updatePodcast(
+        request: Ichos.PodcastUpdate,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.PodcastResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__updatePodcast(request, requestOptions));
+    }
+
+    private async __updatePodcast(
+        request: Ichos.PodcastUpdate,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.PodcastResponse>> {
+        const { podcastId, ..._body } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}`,
+            ),
+            method: "PATCH",
+            headers: _headers,
+            contentType: "application/json",
+            queryParameters: requestOptions?.queryParams,
+            requestType: "json",
+            body: _body,
+            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: _response.body as Ichos.PodcastResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/v1/podcasts/{podcastId}");
+    }
+
+    /**
+     * Get the RSS feed URL for a podcast.
+     * Also triggers an RSS refresh.
+     *
+     * @param {Ichos.GetPodcastRssRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.getPodcastRss({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public getPodcastRss(
+        request: Ichos.GetPodcastRssRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<string> {
+        return core.HttpResponsePromise.fromPromise(this.__getPodcastRss(request, requestOptions));
+    }
+
+    private async __getPodcastRss(
+        request: Ichos.GetPodcastRssRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<string>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/rss`,
+            ),
+            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: _response.body as string, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/v1/podcasts/{podcastId}/rss");
+    }
+
+    /**
+     * Validate a podcast and generate a report.
+     *
+     * @param {Ichos.ValidatePodcastRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.validatePodcast({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public validatePodcast(
+        request: Ichos.ValidatePodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.NullResponse> {
+        return core.HttpResponsePromise.fromPromise(this.__validatePodcast(request, requestOptions));
+    }
+
+    private async __validatePodcast(
+        request: Ichos.ValidatePodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.NullResponse>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/validate`,
+            ),
+            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: _response.body as Ichos.NullResponse, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/v1/podcasts/{podcastId}/validate",
+        );
+    }
+
+    /**
+     * Publish a podcast to make it available via RSS.
+     *
+     * @param {Ichos.PublishPodcastRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.publishPodcast({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public publishPodcast(
+        request: Ichos.PublishPodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.PublishPodcastOutput> {
+        return core.HttpResponsePromise.fromPromise(this.__publishPodcast(request, requestOptions));
+    }
+
+    private async __publishPodcast(
+        request: Ichos.PublishPodcastRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.PublishPodcastOutput>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/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: _response.body as Ichos.PublishPodcastOutput, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "POST",
+            "/v1/podcasts/{podcastId}/publish",
+        );
+    }
+
+    /**
+     * Retrieve listener analytics for a podcast.
+     *
+     * @param {Ichos.GetPodcastListenersReportRequest} request
+     * @param {PodcastsClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @throws {@link Ichos.UnauthorizedError}
+     * @throws {@link Ichos.ForbiddenError}
+     * @throws {@link Ichos.NotFoundError}
+     * @throws {@link Ichos.InternalServerError}
+     *
+     * @example
+     *     await client.podcasts.getPodcastListenersReport({
+     *         podcastId: "podcastId"
+     *     })
+     */
+    public getPodcastListenersReport(
+        request: Ichos.GetPodcastListenersReportRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): core.HttpResponsePromise<Ichos.ListenersReport> {
+        return core.HttpResponsePromise.fromPromise(this.__getPodcastListenersReport(request, requestOptions));
+    }
+
+    private async __getPodcastListenersReport(
+        request: Ichos.GetPodcastListenersReportRequest,
+        requestOptions?: PodcastsClient.RequestOptions,
+    ): Promise<core.WithRawResponse<Ichos.ListenersReport>> {
+        const { podcastId } = request;
+        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
+        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
+            _authRequest.headers,
+            this._options?.headers,
+            mergeOnlyDefinedHeaders({ "x-virtual-user": requestOptions?.virtualUser ?? this._options?.virtualUser }),
+            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)) ??
+                    environments.IchosEnvironment.Default,
+                `v1/podcasts/${core.url.encodePathParam(podcastId)}/analytics/listens`,
+            ),
+            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: _response.body as Ichos.ListenersReport, rawResponse: _response.rawResponse };
+        }
+
+        if (_response.error.reason === "status-code") {
+            switch (_response.error.statusCode) {
+                case 401:
+                    throw new Ichos.UnauthorizedError(
+                        _response.error.body as Ichos.UnauthorizedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 403:
+                    throw new Ichos.ForbiddenError(
+                        _response.error.body as Ichos.UnauthenticatedErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 404:
+                    throw new Ichos.NotFoundError(
+                        _response.error.body as Ichos.NotFoundErrorResponse,
+                        _response.rawResponse,
+                    );
+                case 500:
+                    throw new Ichos.InternalServerError(
+                        _response.error.body as Ichos.InternalServerErrorResponse,
+                        _response.rawResponse,
+                    );
+                default:
+                    throw new errors.IchosError({
+                        statusCode: _response.error.statusCode,
+                        body: _response.error.body,
+                        rawResponse: _response.rawResponse,
+                    });
+            }
+        }
+
+        return handleNonStatusCodeError(
+            _response.error,
+            _response.rawResponse,
+            "GET",
+            "/v1/podcasts/{podcastId}/analytics/listens",
+        );
+    }
+}