Client.ts

// 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 Samsara from "../../../index.js";

export declare namespace BetaApIsClient {
    export type Options = BaseClientOptions;

    export interface RequestOptions extends BaseRequestOptions {}
}

export class BetaApIsClient {
    protected readonly _options: NormalizedClientOptionsWithAuth<BetaApIsClient.Options>;

    constructor(options: BetaApIsClient.Options = {}) {
        this._options = normalizeClientOptionsWithAuth(options);
    }

    /**
     * Returns depreciation and adjustment transactions for assets. Transactions are returned ordered by updatedAt in ascending order (oldest to newest). Use startTime parameter for incremental sync.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Assets** under the Assets category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDepreciationTransactionsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDepreciationTransactions()
     */
    public getDepreciationTransactions(
        request: Samsara.GetDepreciationTransactionsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DepreciationGetDepreciationTransactionsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDepreciationTransactions(request, requestOptions));
    }

    private async __getDepreciationTransactions(
        request: Samsara.GetDepreciationTransactionsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DepreciationGetDepreciationTransactionsResponseBody>> {
        const { startTime, endTime, assetIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            startTime: startTime != null ? startTime : undefined,
            endTime: endTime != null ? endTime : undefined,
            assetIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "assets/depreciation",
            ),
            method: "GET",
            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 Samsara.DepreciationGetDepreciationTransactionsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/assets/depreciation");
    }

    /**
     * This endpoint will return data collected from the inputs of your organization's assets based on the time parameters passed in. Results are paginated. If you include an endTime, the endpoint will return data up until that point. If you don’t include an endTime, you can continue to poll the API real-time with the pagination cursor that gets returned on every call. The endpoint will only return data up until the endTime that has been processed by the server at the time of the original request. You will need to request the same [startTime, endTime) range again to receive data for assets processed after the original request time. This endpoint sorts data by time ascending.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Assets** under the Assets category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetAssetsInputsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getAssetsInputs({
     *         type: "auxInput1",
     *         startTime: "startTime"
     *     })
     */
    public getAssetsInputs(
        request: Samsara.GetAssetsInputsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.AssetsInputsGetAssetsInputsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getAssetsInputs(request, requestOptions));
    }

    private async __getAssetsInputs(
        request: Samsara.GetAssetsInputsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.AssetsInputsGetAssetsInputsResponseBody>> {
        const {
            ids,
            type: type_,
            after,
            startTime,
            endTime,
            includeExternalIds,
            includeTags,
            includeAttributes,
        } = request;
        const _queryParams: Record<string, unknown> = {
            ids,
            type: type_,
            after,
            startTime,
            endTime,
            includeExternalIds,
            includeTags,
            includeAttributes,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "assets/inputs/stream",
            ),
            method: "GET",
            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 Samsara.AssetsInputsGetAssetsInputsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/assets/inputs/stream");
    }

    /**
     * Get a list of equipment following the AEMP ISO 15143-3 standard.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read AEMP** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetAempEquipmentListRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getAempEquipmentList({
     *         pageNumber: "pageNumber"
     *     })
     */
    public getAempEquipmentList(
        request: Samsara.GetAempEquipmentListRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.AempEquipmentGetAempEquipmentListResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getAempEquipmentList(request, requestOptions));
    }

    private async __getAempEquipmentList(
        request: Samsara.GetAempEquipmentListRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.AempEquipmentGetAempEquipmentListResponseBody>> {
        const { pageNumber } = request;
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `beta/aemp/Fleet/${core.url.encodePathParam(pageNumber)}`,
            ),
            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 Samsara.AempEquipmentGetAempEquipmentListResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/beta/aemp/Fleet/{pageNumber}");
    }

    /**
     * Get all driver and associated vehicle efficiency data.
     *
     *  This is a legacy endpoint, consider using this endpoint [/driver-efficiency/drivers](https://developers.samsara.com/reference/getdriverefficiencybydrivers) instead. The endpoint will continue to function as documented.
     *
     *  <b>Rate limit:</b> 50 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * To use this endpoint, select **Read Fuel & Energy** under the Fuel & Energy category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     * @param {Samsara.GetDriverEfficiencyRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @example
     *     await client.betaApIs.getDriverEfficiency()
     */
    public getDriverEfficiency(
        request: Samsara.GetDriverEfficiencyRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DriverEfficienciesResponse> {
        return core.HttpResponsePromise.fromPromise(this.__getDriverEfficiency(request, requestOptions));
    }

    private async __getDriverEfficiency(
        request: Samsara.GetDriverEfficiencyRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DriverEfficienciesResponse>> {
        const { driverActivationStatus, driverIds, after, driverTagIds, driverParentTagIds, startTime, endTime } =
            request;
        const _queryParams: Record<string, unknown> = {
            driverActivationStatus: driverActivationStatus != null ? driverActivationStatus : undefined,
            driverIds,
            after,
            driverTagIds,
            driverParentTagIds,
            startTime: startTime != null ? startTime : undefined,
            endTime: endTime != null ? endTime : undefined,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/fleet/drivers/efficiency",
            ),
            method: "GET",
            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 Samsara.DriverEfficienciesResponse, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            throw new errors.SamsaraError({
                statusCode: _response.error.statusCode,
                body: _response.error.body,
                rawResponse: _response.rawResponse,
            });
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/beta/fleet/drivers/efficiency",
        );
    }

    /**
     * Update an equipment.  **Note** this implementation of patch uses [the JSON merge patch](https://tools.ietf.org/html/rfc7396) proposed standard.
     *  This means that any fields included in the patch request will _overwrite_ fields which exist on the target resource.
     *  For arrays, this means any array included in the request will _replace_ the array that exists at the specified path, it will not _add_ to the existing array
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Equipment** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.EquipmentPatchEquipmentRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.patchEquipment({
     *         id: "id"
     *     })
     */
    public patchEquipment(
        request: Samsara.EquipmentPatchEquipmentRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.EquipmentPatchEquipmentResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__patchEquipment(request, requestOptions));
    }

    private async __patchEquipment(
        request: Samsara.EquipmentPatchEquipmentRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.EquipmentPatchEquipmentResponseBody>> {
        const { id, ..._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-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `beta/fleet/equipment/${core.url.encodePathParam(id)}`,
            ),
            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 Samsara.EquipmentPatchEquipmentResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/beta/fleet/equipment/{id}");
    }

    /**
     * Get all HOS ELD events in a time range, grouped by driver. Attributes will be populated depending on which ELD Event Type is being returned.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read ELD Compliance Settings (US)** under the Compliance category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetHosEldEventsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getHosEldEvents({
     *         startTime: "startTime",
     *         endTime: "endTime"
     *     })
     */
    public getHosEldEvents(
        request: Samsara.GetHosEldEventsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.HosEldEventsGetHosEldEventsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getHosEldEvents(request, requestOptions));
    }

    private async __getHosEldEvents(
        request: Samsara.GetHosEldEventsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.HosEldEventsGetHosEldEventsResponseBody>> {
        const { startTime, endTime, driverIds, tagIds, parentTagIds, driverActivationStatus, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            startTime,
            endTime,
            driverIds,
            tagIds,
            parentTagIds,
            driverActivationStatus: driverActivationStatus != null ? driverActivationStatus : undefined,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/fleet/hos/drivers/eld-events",
            ),
            method: "GET",
            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 Samsara.HosEldEventsGetHosEldEventsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/beta/fleet/hos/drivers/eld-events",
        );
    }

    /**
     * Returns the last known stats of all trailers at the given `time`. If no `time` is specified, the current time is used.
     *
     *  <b>Rate limit:</b> 25 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Trailer Statistics** under the Trailers category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetTrailerStatsSnapshotRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getTrailerStatsSnapshot({
     *         types: "types"
     *     })
     */
    public getTrailerStatsSnapshot(
        request: Samsara.GetTrailerStatsSnapshotRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.TrailerStatsGetTrailerStatsSnapshotResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getTrailerStatsSnapshot(request, requestOptions));
    }

    private async __getTrailerStatsSnapshot(
        request: Samsara.GetTrailerStatsSnapshotRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.TrailerStatsGetTrailerStatsSnapshotResponseBody>> {
        const { types, tagIds, parentTagIds, after, trailerIds, time } = request;
        const _queryParams: Record<string, unknown> = {
            types,
            tagIds,
            parentTagIds,
            after,
            trailerIds,
            time,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/fleet/trailers/stats",
            ),
            method: "GET",
            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 Samsara.TrailerStatsGetTrailerStatsSnapshotResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/beta/fleet/trailers/stats");
    }

    /**
     * Follow a feed of trailer stats.
     *
     * The first call to this endpoint will provide the most recent stats for each trailer and an `endCursor`.
     *
     * Providing the `endCursor` value to the `after` query parameter will fetch all updates since the previous API call.
     *
     * If `hasNextPage` is false, no new data is immediately available. Please wait a minimum of 5 seconds before making a subsequent request.
     *
     *  <b>Rate limit:</b> 25 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Trailer Statistics** under the Trailers category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetTrailerStatsFeedRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getTrailerStatsFeed({
     *         types: "types"
     *     })
     */
    public getTrailerStatsFeed(
        request: Samsara.GetTrailerStatsFeedRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.TrailerStatsGetTrailerStatsFeedResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getTrailerStatsFeed(request, requestOptions));
    }

    private async __getTrailerStatsFeed(
        request: Samsara.GetTrailerStatsFeedRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.TrailerStatsGetTrailerStatsFeedResponseBody>> {
        const { types, tagIds, parentTagIds, after, trailerIds, decorations } = request;
        const _queryParams: Record<string, unknown> = {
            types,
            tagIds,
            parentTagIds,
            after,
            trailerIds,
            decorations,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/fleet/trailers/stats/feed",
            ),
            method: "GET",
            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 Samsara.TrailerStatsGetTrailerStatsFeedResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/beta/fleet/trailers/stats/feed",
        );
    }

    /**
     * Returns trailer stats during the given time range for all trailers. This can be optionally filtered by tags or specific trailer IDs.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Trailer Statistics** under the Trailers category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetTrailerStatsHistoryRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getTrailerStatsHistory({
     *         startTime: "startTime",
     *         endTime: "endTime",
     *         types: "types"
     *     })
     */
    public getTrailerStatsHistory(
        request: Samsara.GetTrailerStatsHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.TrailerStatsGetTrailerStatsHistoryResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getTrailerStatsHistory(request, requestOptions));
    }

    private async __getTrailerStatsHistory(
        request: Samsara.GetTrailerStatsHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.TrailerStatsGetTrailerStatsHistoryResponseBody>> {
        const { startTime, endTime, types, tagIds, parentTagIds, after, trailerIds, decorations } = request;
        const _queryParams: Record<string, unknown> = {
            startTime,
            endTime,
            types,
            tagIds,
            parentTagIds,
            after,
            trailerIds,
            decorations,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/fleet/trailers/stats/history",
            ),
            method: "GET",
            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 Samsara.TrailerStatsGetTrailerStatsHistoryResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/beta/fleet/trailers/stats/history",
        );
    }

    /**
     * Update the engine immobilizer state of a vehicle. This requires an engine immobilizer to be installed on the vehicle gateway.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Vehicle Immobilization** under the Vehicles category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.EngineImmobilizerUpdateEngineImmobilizerStateRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.updateEngineImmobilizerState({
     *         id: 1000000,
     *         relayStates: [{
     *                 id: "relay1",
     *                 isOpen: true
     *             }]
     *     })
     */
    public updateEngineImmobilizerState(
        request: Samsara.EngineImmobilizerUpdateEngineImmobilizerStateRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__updateEngineImmobilizerState(request, requestOptions));
    }

    private async __updateEngineImmobilizerState(
        request: Samsara.EngineImmobilizerUpdateEngineImmobilizerStateRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const { id, ..._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-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `beta/fleet/vehicles/${core.url.encodePathParam(id)}/immobilizer`,
            ),
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "PATCH",
            "/beta/fleet/vehicles/{id}/immobilizer",
        );
    }

    /**
     * Fetches jobs based on id/uuid or provided filters.
     *
     * To use this endpoint, select **Read Jobs** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetJobsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getJobs()
     */
    public getJobs(
        request: Samsara.GetJobsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.JobsGetJobsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getJobs(request, requestOptions));
    }

    private async __getJobs(
        request: Samsara.GetJobsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.JobsGetJobsResponseBody>> {
        const { id, startDate, endDate, industrialAssetIds, fleetDeviceIds, status, customerName, after } = request;
        const _queryParams: Record<string, unknown> = {
            id,
            startDate,
            endDate,
            industrialAssetIds,
            fleetDeviceIds,
            status: status != null ? status : undefined,
            customerName,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/industrial/jobs",
            ),
            method: "GET",
            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 Samsara.JobsGetJobsResponseBody, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/beta/industrial/jobs");
    }

    /**
     * Creates a new job and returns it.
     *
     * To use this endpoint, select **Write Jobs** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.JobsCreateJobRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createJob({
     *         job: {
     *             endDate: "2019-06-13T19:08:25Z",
     *             id: "8d218e6c-7a16-4f9f-90f7-cc1d93b9e596",
     *             name: "My Job Name",
     *             startDate: "2019-06-13T19:08:25Z"
     *         }
     *     })
     */
    public createJob(
        request: Samsara.JobsCreateJobRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.JobsCreateJobResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createJob(request, requestOptions));
    }

    private async __createJob(
        request: Samsara.JobsCreateJobRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.JobsCreateJobResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/industrial/jobs",
            ),
            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 Samsara.JobsCreateJobResponseBody, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/beta/industrial/jobs");
    }

    /**
     * Deletes an existing job.
     *
     * To use this endpoint, select **Write Jobs** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeleteJobRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.deleteJob({
     *         id: "id"
     *     })
     */
    public deleteJob(
        request: Samsara.DeleteJobRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.JobsDeleteJobResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__deleteJob(request, requestOptions));
    }

    private async __deleteJob(
        request: Samsara.DeleteJobRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.JobsDeleteJobResponseBody>> {
        const { id } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/industrial/jobs",
            ),
            method: "DELETE",
            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 Samsara.JobsDeleteJobResponseBody, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/beta/industrial/jobs");
    }

    /**
     * Patches an existing job and returns it.
     *
     * To use this endpoint, select **Write Jobs** under the Equipment category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.JobsPatchJobRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.patchJob({
     *         id: "id",
     *         job: {}
     *     })
     */
    public patchJob(
        request: Samsara.JobsPatchJobRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.JobsPatchJobResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__patchJob(request, requestOptions));
    }

    private async __patchJob(
        request: Samsara.JobsPatchJobRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.JobsPatchJobResponseBody>> {
        const { id, ..._body } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "beta/industrial/jobs",
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...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 Samsara.JobsPatchJobResponseBody, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/beta/industrial/jobs");
    }

    /**
     * This endpoint will return all detections detected by in-vehicle assets and associated metadata. To get core endpoint data, select View Safety Detection Log under the Safety & Cameras category when creating or editing an API token.
     *
     * If you include an endTime, the endpoint will return data up until that point. If you don’t include an endTime, you can continue to poll the API real-time with the pagination cursor that gets returned on every call. Results are paginated.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Detection Log** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDetectionsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDetections({
     *         startTime: "startTime"
     *     })
     */
    public getDetections(
        request: Samsara.GetDetectionsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DetectionLogGetDetectionsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDetections(request, requestOptions));
    }

    private async __getDetections(
        request: Samsara.GetDetectionsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DetectionLogGetDetectionsResponseBody>> {
        const {
            driverIds,
            assetIds,
            detectionBehaviorLabels,
            inboxFilterReason,
            inboxEvent,
            inCabAlertPlayed,
            tagIds,
            includeAsset,
            includeDriver,
            startTime,
            endTime,
            after,
        } = request;
        const _queryParams: Record<string, unknown> = {
            driverIds,
            assetIds,
            detectionBehaviorLabels,
            inboxFilterReason,
            inboxEvent,
            inCabAlertPlayed,
            tagIds,
            includeAsset,
            includeDriver,
            startTime,
            endTime,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "detections/stream",
            ),
            method: "GET",
            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 Samsara.DetectionLogGetDetectionsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/detections/stream");
    }

    /**
     * Returns all installed cameras (CM3x), vehicle gateways (VGs), and asset gateways (AGs) and their health information within an organization.
     *
     * **Beta:** This endpoint is in beta and is likely to change before being broadly available. Reach out to your Samsara Representative to have Devices API enabled for your organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Devices** under the Devices category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDevicesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDevices()
     */
    public getDevices(
        request: Samsara.GetDevicesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DevicesGetDevicesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDevices(request, requestOptions));
    }

    private async __getDevices(
        request: Samsara.GetDevicesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DevicesGetDevicesResponseBody>> {
        const { models, healthStatuses, includeHealth, after, limit, includeTags, tagIds, parentTagIds } = request;
        const _queryParams: Record<string, unknown> = {
            models,
            healthStatuses,
            includeHealth,
            after,
            limit,
            includeTags,
            tagIds,
            parentTagIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "devices",
            ),
            method: "GET",
            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 Samsara.DevicesGetDevicesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/devices");
    }

    /**
     * List all assets that are currently marked as missing for the organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Assets** under the Assets category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListDeviceRecoveryMissingAssetsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listDeviceRecoveryMissingAssets()
     */
    public listDeviceRecoveryMissingAssets(
        request: Samsara.ListDeviceRecoveryMissingAssetsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DeviceRecoveryListDeviceRecoveryMissingAssetsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listDeviceRecoveryMissingAssets(request, requestOptions));
    }

    private async __listDeviceRecoveryMissingAssets(
        request: Samsara.ListDeviceRecoveryMissingAssetsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DeviceRecoveryListDeviceRecoveryMissingAssetsResponseBody>> {
        const { after } = request;
        const _queryParams: Record<string, unknown> = {
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/assets/device-recovery-missing",
            ),
            method: "GET",
            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 Samsara.DeviceRecoveryListDeviceRecoveryMissingAssetsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/fleet/assets/device-recovery-missing",
        );
    }

    /**
     * Mark an asset as missing. Optionally specify a note and notification recipients who will receive email updates.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Assets** under the Assets category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeviceRecoveryMarkAssetMissingRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.markAssetMissing({
     *         id: "id"
     *     })
     */
    public markAssetMissing(
        request: Samsara.DeviceRecoveryMarkAssetMissingRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DeviceRecoveryMarkAssetMissingResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__markAssetMissing(request, requestOptions));
    }

    private async __markAssetMissing(
        request: Samsara.DeviceRecoveryMarkAssetMissingRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DeviceRecoveryMarkAssetMissingResponseBody>> {
        const { id, ..._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-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `fleet/assets/device-recovery/${core.url.encodePathParam(id)}/missing`,
            ),
            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 Samsara.DeviceRecoveryMarkAssetMissingResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "POST",
            "/fleet/assets/device-recovery/{id}/missing",
        );
    }

    /**
     * Mark a missing asset as recovered. Provide the recovery status, reason for being missing, and optional additional details.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Assets** under the Assets category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeviceRecoveryRecoverAssetRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.recoverAsset({
     *         id: "id",
     *         missing_reason: "MISPLACED",
     *         recovery_status: "YES",
     *         status: "RECOVERED"
     *     })
     */
    public recoverAsset(
        request: Samsara.DeviceRecoveryRecoverAssetRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.DeviceRecoveryRecoverAssetResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__recoverAsset(request, requestOptions));
    }

    private async __recoverAsset(
        request: Samsara.DeviceRecoveryRecoverAssetRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.DeviceRecoveryRecoverAssetResponseBody>> {
        const { id, ..._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-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `fleet/assets/device-recovery/${core.url.encodePathParam(id)}/recovered`,
            ),
            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 Samsara.DeviceRecoveryRecoverAssetResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "POST",
            "/fleet/assets/device-recovery/{id}/recovered",
        );
    }

    /**
     * Returns a paginated list of vehicles enrolled in the CARB CTC program with their latest compliance status. Results can be filtered by tag IDs and test status.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read CARB CTC Integration** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListCarbCtcVehiclesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listCarbCtcVehicles()
     */
    public listCarbCtcVehicles(
        request: Samsara.ListCarbCtcVehiclesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.CarbCtcListCarbCtcVehiclesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listCarbCtcVehicles(request, requestOptions));
    }

    private async __listCarbCtcVehicles(
        request: Samsara.ListCarbCtcVehiclesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.CarbCtcListCarbCtcVehiclesResponseBody>> {
        const { tagIds, parentTagIds, testStatus, after } = request;
        const _queryParams: Record<string, unknown> = {
            tagIds,
            parentTagIds,
            testStatus: Array.isArray(testStatus)
                ? testStatus.map((item) => item)
                : testStatus != null
                  ? testStatus
                  : undefined,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/carb-ctc/vehicles",
            ),
            method: "GET",
            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 Samsara.CarbCtcListCarbCtcVehiclesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/fleet/carb-ctc/vehicles");
    }

    /**
     * Returns paginated collection history for a batch of vehicles enrolled in the CARB CTC program. Use vehicle IDs from the list enrolled vehicles endpoint. Optionally filter by time range. Results are ordered by happenedAtTime descending, with vehicle ID as a tiebreaker.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read CARB CTC Integration** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListCarbCtcVehicleHistoryRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listCarbCtcVehicleHistory({
     *         vehicleIds: "vehicleIds"
     *     })
     */
    public listCarbCtcVehicleHistory(
        request: Samsara.ListCarbCtcVehicleHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.CarbCtcListCarbCtcVehicleHistoryResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listCarbCtcVehicleHistory(request, requestOptions));
    }

    private async __listCarbCtcVehicleHistory(
        request: Samsara.ListCarbCtcVehicleHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.CarbCtcListCarbCtcVehicleHistoryResponseBody>> {
        const { vehicleIds, startTime, endTime, after } = request;
        const _queryParams: Record<string, unknown> = {
            vehicleIds,
            startTime,
            endTime,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/carb-ctc/vehicles/history",
            ),
            method: "GET",
            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 Samsara.CarbCtcListCarbCtcVehicleHistoryResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/fleet/carb-ctc/vehicles/history",
        );
    }

    /**
     * Resolves a driver by name within an organization via voice sign-in, then creates a driver-vehicle assignment via the Driver Assignment Service.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Assignments** under the Assignments category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.resolveAssignmentByDetails({
     *         driverName: "Jane Doe",
     *         vehicleId: "281474978683353"
     *     })
     */
    public resolveAssignmentByDetails(
        request: Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__resolveAssignmentByDetails(request, requestOptions));
    }

    private async __resolveAssignmentByDetails(
        request: Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/drivers/voice-sign-in/resolve-assignment",
            ),
            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 Samsara.ResolveAssignmentByDetailsResolveAssignmentByDetailsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "POST",
            "/fleet/drivers/voice-sign-in/resolve-assignment",
        );
    }

    /**
     * Returns the list of vendor categories available for maintenance vendors.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Work Orders** under the Work Orders category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListVendorCategoriesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listVendorCategories()
     */
    public listVendorCategories(
        request: Samsara.ListVendorCategoriesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.MaintenanceVendorsListVendorCategoriesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listVendorCategories(request, requestOptions));
    }

    private async __listVendorCategories(
        request: Samsara.ListVendorCategoriesRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.MaintenanceVendorsListVendorCategoriesResponseBody>> {
        const { after } = request;
        const _queryParams: Record<string, unknown> = {
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/maintenance/vendor-categories",
            ),
            method: "GET",
            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 Samsara.MaintenanceVendorsListVendorCategoriesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/fleet/maintenance/vendor-categories",
        );
    }

    /**
     * Returns a paginated list of maintenance vendors in the organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Work Orders** under the Work Orders category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListMaintenanceVendorsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listMaintenanceVendors()
     */
    public listMaintenanceVendors(
        request: Samsara.ListMaintenanceVendorsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.MaintenanceVendorsListMaintenanceVendorsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listMaintenanceVendors(request, requestOptions));
    }

    private async __listMaintenanceVendors(
        request: Samsara.ListMaintenanceVendorsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.MaintenanceVendorsListMaintenanceVendorsResponseBody>> {
        const { ids, includeExternalIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            ids,
            includeExternalIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/maintenance/vendors",
            ),
            method: "GET",
            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 Samsara.MaintenanceVendorsListMaintenanceVendorsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/fleet/maintenance/vendors");
    }

    /**
     * Get the engine immobilizer states of the queried vehicles. If a vehicle has never had an engine immobilizer connected, there won't be any state returned for that vehicle.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Vehicle Immobilization** under the Vehicles category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetEngineImmobilizerStatesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getEngineImmobilizerStates({
     *         vehicleIds: "vehicleIds",
     *         startTime: "startTime"
     *     })
     */
    public getEngineImmobilizerStates(
        request: Samsara.GetEngineImmobilizerStatesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.EngineImmobilizerGetEngineImmobilizerStatesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getEngineImmobilizerStates(request, requestOptions));
    }

    private async __getEngineImmobilizerStates(
        request: Samsara.GetEngineImmobilizerStatesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.EngineImmobilizerGetEngineImmobilizerStatesResponseBody>> {
        const { vehicleIds, startTime, endTime, after } = request;
        const _queryParams: Record<string, unknown> = {
            vehicleIds,
            startTime,
            endTime,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "fleet/vehicles/immobilizer/stream",
            ),
            method: "GET",
            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 Samsara.EngineImmobilizerGetEngineImmobilizerStatesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/fleet/vehicles/immobilizer/stream",
        );
    }

    /**
     * Start an asynchronous run for the specified Function. This endpoint allows you to override parameters available at runtime.
     *
     *  <b>Rate limit:</b> 2 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Functions** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.FunctionsStartFunctionRunRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.startFunctionRun({
     *         name: "name",
     *         paramsOverride: {}
     *     })
     */
    public startFunctionRun(
        request: Samsara.FunctionsStartFunctionRunRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.FunctionsStartFunctionRunResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__startFunctionRun(request, requestOptions));
    }

    private async __startFunctionRun(
        request: Samsara.FunctionsStartFunctionRunRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.FunctionsStartFunctionRunResponseBody>> {
        const { name, ..._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-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `functions/${core.url.encodePathParam(name)}/runs`,
            ),
            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 Samsara.FunctionsStartFunctionRunResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/functions/{name}/runs");
    }

    /**
     * Update the shippingDocs field of an existing assignment.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write ELD Hours of Service (US)** under the Compliance category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.HosDailyLogsUpdateShippingDocsRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.updateShippingDocs({
     *         hosDate: "hosDate",
     *         driverID: "driverID",
     *         shippingDocs: "ShippingID1, ShippingID2"
     *     })
     */
    public updateShippingDocs(
        request: Samsara.HosDailyLogsUpdateShippingDocsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.HosDailyLogsUpdateShippingDocsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__updateShippingDocs(request, requestOptions));
    }

    private async __updateShippingDocs(
        request: Samsara.HosDailyLogsUpdateShippingDocsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.HosDailyLogsUpdateShippingDocsResponseBody>> {
        const { hosDate, driverID: driverId, ..._body } = request;
        const _queryParams: Record<string, unknown> = {
            hosDate,
            driverID: driverId,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "hos/daily-logs/log-meta-data",
            ),
            method: "PATCH",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...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 Samsara.HosDailyLogsUpdateShippingDocsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "PATCH",
            "/hos/daily-logs/log-meta-data",
        );
    }

    /**
     * Retrieve custom properties for a specific hub.
     *
     * **Beta:** This endpoint is in beta and is likely to change before being broadly available. Reach out to your Samsara Representative to have RoutePlanning APIs enabled for your organization.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Routes** under the Driver Workflow category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListHubCustomPropertiesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listHubCustomProperties({
     *         hubId: "hubId"
     *     })
     */
    public listHubCustomProperties(
        request: Samsara.ListHubCustomPropertiesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.HubCustomPropertiesListHubCustomPropertiesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listHubCustomProperties(request, requestOptions));
    }

    private async __listHubCustomProperties(
        request: Samsara.ListHubCustomPropertiesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.HubCustomPropertiesListHubCustomPropertiesResponseBody>> {
        const { hubId, customPropertyIds, customPropertyNames, startTime, endTime, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            hubId,
            customPropertyIds,
            customPropertyNames,
            startTime: startTime != null ? startTime : undefined,
            endTime: endTime != null ? endTime : undefined,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "hub/customProperties",
            ),
            method: "GET",
            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 Samsara.HubCustomPropertiesListHubCustomPropertiesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/hub/customProperties");
    }

    /**
     * Create one or more orders (bulk upsert). Pass an array of order objects; any object whose customerOrderId already exists will be updated, otherwise a new order is created. Functions can return JSON arrays in this Order POST format. Orders are initially created at the plan level but will migrate to hub-level entities, with planId becoming optional in future versions.
     *
     * **Beta:** This endpoint is in beta and is likely to change before being broadly available. Reach out to your Samsara Representative to have RoutePlanning APIs enabled for your organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Routes** under the Driver Workflow category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.PlanOrdersCreatePlanOrdersRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createPlanOrders({
     *         data: [{
     *                 customerOrderId: "ORDER-2024-001",
     *                 hubId: "550e8400-e29b-41d4-a716-446655440000",
     *                 planId: "650e8400-e29b-41d4-a716-446655440023"
     *             }]
     *     })
     */
    public createPlanOrders(
        request: Samsara.PlanOrdersCreatePlanOrdersRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.PlanOrdersCreatePlanOrdersResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createPlanOrders(request, requestOptions));
    }

    private async __createPlanOrders(
        request: Samsara.PlanOrdersCreatePlanOrdersRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.PlanOrdersCreatePlanOrdersResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "hub/plan/orders",
            ),
            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 Samsara.PlanOrdersCreatePlanOrdersResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/hub/plan/orders");
    }

    /**
     * Returns qualification records for the specified list of IDs.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetQualificationRecordsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getQualificationRecords()
     */
    public getQualificationRecords(
        request: Samsara.GetQualificationRecordsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.QualificationsGetQualificationRecordsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getQualificationRecords(request, requestOptions));
    }

    private async __getQualificationRecords(
        request: Samsara.GetQualificationRecordsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.QualificationsGetQualificationRecordsResponseBody>> {
        const { ids, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            ids,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records",
            ),
            method: "GET",
            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 Samsara.QualificationsGetQualificationRecordsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/qualification-records");
    }

    /**
     * Creates a new qualification record.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.QualificationsPostQualificationRecordRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.postQualificationRecord({
     *         fields: [{
     *                 id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7",
     *                 type: "number"
     *             }],
     *         issueDate: "2025-08-27T10:20:30Z",
     *         owner: {
     *             entityType: "worker",
     *             id: "281474"
     *         },
     *         qualificationType: {
     *             id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7"
     *         }
     *     })
     */
    public postQualificationRecord(
        request: Samsara.QualificationsPostQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.QualificationsPostQualificationRecordResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__postQualificationRecord(request, requestOptions));
    }

    private async __postQualificationRecord(
        request: Samsara.QualificationsPostQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.QualificationsPostQualificationRecordResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records",
            ),
            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 Samsara.QualificationsPostQualificationRecordResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/qualification-records");
    }

    /**
     * Deletes an existing qualification record.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.QualificationsDeleteQualificationRecordRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.deleteQualificationRecord({
     *         id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7"
     *     })
     */
    public deleteQualificationRecord(
        request: Samsara.QualificationsDeleteQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteQualificationRecord(request, requestOptions));
    }

    private async __deleteQualificationRecord(
        request: Samsara.QualificationsDeleteQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records",
            ),
            method: "DELETE",
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/qualification-records");
    }

    /**
     * Updates an existing qualification record.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.QualificationsPatchQualificationRecordRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.patchQualificationRecord({
     *         id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7",
     *         issueDate: "2025-08-27T10:20:30Z",
     *         owner: {
     *             entityType: "worker",
     *             id: "281474"
     *         }
     *     })
     */
    public patchQualificationRecord(
        request: Samsara.QualificationsPatchQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.QualificationsPatchQualificationRecordResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__patchQualificationRecord(request, requestOptions));
    }

    private async __patchQualificationRecord(
        request: Samsara.QualificationsPatchQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.QualificationsPatchQualificationRecordResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records",
            ),
            method: "PATCH",
            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 Samsara.QualificationsPatchQualificationRecordResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PATCH", "/qualification-records");
    }

    /**
     * Archives an existing qualification record.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.QualificationsArchiveQualificationRecordRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.archiveQualificationRecord({
     *         id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7"
     *     })
     */
    public archiveQualificationRecord(
        request: Samsara.QualificationsArchiveQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__archiveQualificationRecord(request, requestOptions));
    }

    private async __archiveQualificationRecord(
        request: Samsara.QualificationsArchiveQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records/archive",
            ),
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "POST",
            "/qualification-records/archive",
        );
    }

    /**
     * Returns all qualification records that have been created or modified for your organization based on the time parameters passed in. Results are paginated and are sorted by last modified date. If you include an endTime, the endpoint will return data up until that point (exclusive). If you don't include an endTime, the API will continue to poll with the pagination cursor that gets returned on every call. The hasNextPage response value will be true if there is no endTime specified and endCursor is nonempty.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetQualificationRecordsStreamRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getQualificationRecordsStream({
     *         entityType: "worker",
     *         startTime: "2024-01-15T09:30:00Z"
     *     })
     */
    public getQualificationRecordsStream(
        request: Samsara.GetQualificationRecordsStreamRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.QualificationsGetQualificationRecordsStreamResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getQualificationRecordsStream(request, requestOptions));
    }

    private async __getQualificationRecordsStream(
        request: Samsara.GetQualificationRecordsStreamRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.QualificationsGetQualificationRecordsStreamResponseBody>> {
        const {
            entityType,
            startTime,
            endTime,
            after,
            qualificationTypeIds,
            ownerIds,
            includeDeleted,
            includeExternalIds,
        } = request;
        const _queryParams: Record<string, unknown> = {
            entityType,
            startTime,
            endTime: endTime != null ? endTime : undefined,
            after,
            qualificationTypeIds,
            ownerIds,
            includeDeleted,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records/stream",
            ),
            method: "GET",
            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 Samsara.QualificationsGetQualificationRecordsStreamResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/qualification-records/stream");
    }

    /**
     * Unarchives an existing qualification record.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.QualificationsUnarchiveQualificationRecordRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.unarchiveQualificationRecord({
     *         id: "9814a1fa-f0c6-408b-bf85-51dc3bc71ac7"
     *     })
     */
    public unarchiveQualificationRecord(
        request: Samsara.QualificationsUnarchiveQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__unarchiveQualificationRecord(request, requestOptions));
    }

    private async __unarchiveQualificationRecord(
        request: Samsara.QualificationsUnarchiveQualificationRecordRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-records/unarchive",
            ),
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "POST",
            "/qualification-records/unarchive",
        );
    }

    /**
     * Returns a list of qualification types for the specified list of IDs. If no IDs are provided, all qualification types will be returned.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Qualification Records** under the Qualification Records category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetQualificationTypesRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getQualificationTypes({
     *         entityType: "worker"
     *     })
     */
    public getQualificationTypes(
        request: Samsara.GetQualificationTypesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.QualificationsGetQualificationTypesResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getQualificationTypes(request, requestOptions));
    }

    private async __getQualificationTypes(
        request: Samsara.GetQualificationTypesRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.QualificationsGetQualificationTypesResponseBody>> {
        const { entityType, ids, after } = request;
        const _queryParams: Record<string, unknown> = {
            entityType,
            ids,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "qualification-types",
            ),
            method: "GET",
            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 Samsara.QualificationsGetQualificationTypesResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/qualification-types");
    }

    /**
     * Ingest new readings. This endpoint allows the ingestion of batches of readings.
     *
     * Ingesting readings is only supported for assets created using the POST /assets API endpoint with readingsIngestionEnabled set to true. To see a full list of readings available for ingestion use the GET readings definitions API. When ingesting location data, the readingID 'location' must be used and the value object must contain at least the following fields: 'speed', 'latitude', 'longitude'.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Readings** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ReadingsPostReadingsRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.postReadings({
     *         data: [{
     *                 entityId: "123451234512345",
     *                 entityType: "asset",
     *                 happenedAtTime: "2023-10-27T10:00:00Z",
     *                 readingId: "airInletPressure",
     *                 value: {
     *                     "key": "value"
     *                 }
     *             }]
     *     })
     */
    public postReadings(
        request: Samsara.ReadingsPostReadingsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__postReadings(request, requestOptions));
    }

    private async __postReadings(
        request: Samsara.ReadingsPostReadingsRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "readings",
            ),
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/readings");
    }

    /**
     * An introspection endpoint for discovering the set of readings including their name, description, data type, unit, and other metadata.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Readings** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListReadingsDefinitionsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listReadingsDefinitions()
     */
    public listReadingsDefinitions(
        request: Samsara.ListReadingsDefinitionsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReadingsListReadingsDefinitionsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listReadingsDefinitions(request, requestOptions));
    }

    private async __listReadingsDefinitions(
        request: Samsara.ListReadingsDefinitionsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReadingsListReadingsDefinitionsResponseBody>> {
        const { after, ids, entityTypes } = request;
        const _queryParams: Record<string, unknown> = {
            after,
            ids,
            entityTypes,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "readings/definitions",
            ),
            method: "GET",
            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 Samsara.ReadingsListReadingsDefinitionsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/readings/definitions");
    }

    /**
     * Get the values of a reading for a set of entities within the specified time range. Returns a paginated response with data for the specified resource IDs where startTime <= happenedAtTime < endTime. End time of null implies endTime is infinite and all known readings are returned.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Readings** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetReadingsHistoryRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getReadingsHistory({
     *         readingId: "readingId",
     *         entityType: "entityType"
     *     })
     */
    public getReadingsHistory(
        request: Samsara.GetReadingsHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReadingsGetReadingsHistoryResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getReadingsHistory(request, requestOptions));
    }

    private async __getReadingsHistory(
        request: Samsara.GetReadingsHistoryRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReadingsGetReadingsHistoryResponseBody>> {
        const { after, readingId, entityIds, entityType, externalIds, startTime, endTime, feed, includeExternalIds } =
            request;
        const _queryParams: Record<string, unknown> = {
            after,
            readingId,
            entityIds,
            entityType,
            externalIds,
            startTime,
            endTime,
            feed,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "readings/history",
            ),
            method: "GET",
            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 Samsara.ReadingsGetReadingsHistoryResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/readings/history");
    }

    /**
     * An endpoint to get the last value of a reading for a set of entities at the specified time.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Readings** under the Closed Beta category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetReadingsSnapshotRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getReadingsSnapshot({
     *         readingIds: "readingIds",
     *         entityType: "entityType"
     *     })
     */
    public getReadingsSnapshot(
        request: Samsara.GetReadingsSnapshotRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReadingsGetReadingsSnapshotResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getReadingsSnapshot(request, requestOptions));
    }

    private async __getReadingsSnapshot(
        request: Samsara.GetReadingsSnapshotRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReadingsGetReadingsSnapshotResponseBody>> {
        const { after, readingIds, entityIds, externalIds, asOfTime, entityType, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            after,
            readingIds,
            entityIds,
            externalIds,
            asOfTime,
            entityType,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "readings/latest",
            ),
            method: "GET",
            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 Samsara.ReadingsGetReadingsSnapshotResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/readings/latest");
    }

    /**
     * Get report configs created in the organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Custom Reports** under the Custom Reports category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetReportConfigsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getReportConfigs()
     */
    public getReportConfigs(
        request: Samsara.GetReportConfigsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReportsGetReportConfigsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getReportConfigs(request, requestOptions));
    }

    private async __getReportConfigs(
        request: Samsara.GetReportConfigsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReportsGetReportConfigsResponseBody>> {
        const { after, limit, ids } = request;
        const _queryParams: Record<string, unknown> = {
            after,
            limit,
            ids,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "reports/configs",
            ),
            method: "GET",
            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 Samsara.ReportsGetReportConfigsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/reports/configs");
    }

    /**
     * Get datasets for custom reports.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Custom Reports** under the Custom Reports category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDatasetsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDatasets()
     */
    public getDatasets(
        request: Samsara.GetDatasetsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReportsGetDatasetsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDatasets(request, requestOptions));
    }

    private async __getDatasets(
        request: Samsara.GetDatasetsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReportsGetDatasetsResponseBody>> {
        const { ids, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            ids,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "reports/datasets",
            ),
            method: "GET",
            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 Samsara.ReportsGetDatasetsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/reports/datasets");
    }

    /**
     * Get custom report runs created by the user.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Custom Reports** under the Custom Reports category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetReportRunsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getReportRuns()
     */
    public getReportRuns(
        request: Samsara.GetReportRunsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReportsGetReportRunsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getReportRuns(request, requestOptions));
    }

    private async __getReportRuns(
        request: Samsara.GetReportRunsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReportsGetReportRunsResponseBody>> {
        const { reportConfigIds, ids, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            reportConfigIds,
            ids,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "reports/runs",
            ),
            method: "GET",
            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 Samsara.ReportsGetReportRunsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/reports/runs");
    }

    /**
     * Triggers a new custom report run based on the provided configuration.
     *
     *  <b>Rate limit:</b> 50 requests/hour (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Custom Reports** under the Custom Reports category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ReportsCreateReportRunRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createReportRun({
     *         reportConfig: {}
     *     })
     */
    public createReportRun(
        request: Samsara.ReportsCreateReportRunRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReportsCreateReportRunResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createReportRun(request, requestOptions));
    }

    private async __createReportRun(
        request: Samsara.ReportsCreateReportRunRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReportsCreateReportRunResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "reports/runs",
            ),
            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 Samsara.ReportsCreateReportRunResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/reports/runs");
    }

    /**
     * Get data for the given custom report run.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Custom Reports** under the Custom Reports category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetReportRunDataRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getReportRunData({
     *         id: "id"
     *     })
     */
    public getReportRunData(
        request: Samsara.GetReportRunDataRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.ReportsGetReportRunDataResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getReportRunData(request, requestOptions));
    }

    private async __getReportRunData(
        request: Samsara.GetReportRunDataRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.ReportsGetReportRunDataResponseBody>> {
        const { id, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            id,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "reports/runs/data",
            ),
            method: "GET",
            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 Samsara.ReportsGetReportRunDataResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/reports/runs/data");
    }

    /**
     * List all ridership accounts for the organization.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListRidershipAccountsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listRidershipAccounts()
     */
    public listRidershipAccounts(
        request: Samsara.ListRidershipAccountsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipAccountsListRidershipAccountsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listRidershipAccounts(request, requestOptions));
    }

    private async __listRidershipAccounts(
        request: Samsara.ListRidershipAccountsRequest = {},
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipAccountsListRidershipAccountsResponseBody>> {
        const { after, limit, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            after,
            limit,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/accounts",
            ),
            method: "GET",
            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 Samsara.RidershipAccountsListRidershipAccountsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/ridership/accounts");
    }

    /**
     * Create a new ridership account.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipAccountsCreateRidershipAccountRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createRidershipAccount({
     *         name: "Springfield Public Schools"
     *     })
     */
    public createRidershipAccount(
        request: Samsara.RidershipAccountsCreateRidershipAccountRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipAccountsCreateRidershipAccountResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createRidershipAccount(request, requestOptions));
    }

    private async __createRidershipAccount(
        request: Samsara.RidershipAccountsCreateRidershipAccountRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipAccountsCreateRidershipAccountResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/accounts",
            ),
            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 Samsara.RidershipAccountsCreateRidershipAccountResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/ridership/accounts");
    }

    /**
     * Update a ridership account by Samsara ID. All provided fields will overwrite existing values (PUT semantics).
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipAccountsUpdateRidershipAccountRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.updateRidershipAccount({
     *         id: "id",
     *         name: "Springfield Public Schools"
     *     })
     */
    public updateRidershipAccount(
        request: Samsara.RidershipAccountsUpdateRidershipAccountRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipAccountsUpdateRidershipAccountResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__updateRidershipAccount(request, requestOptions));
    }

    private async __updateRidershipAccount(
        request: Samsara.RidershipAccountsUpdateRidershipAccountRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipAccountsUpdateRidershipAccountResponseBody>> {
        const { id, ..._body } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/accounts",
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...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 Samsara.RidershipAccountsUpdateRidershipAccountResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/ridership/accounts");
    }

    /**
     * Delete a ridership account by Samsara ID.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeleteRidershipAccountRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.deleteRidershipAccount({
     *         id: "id"
     *     })
     */
    public deleteRidershipAccount(
        request: Samsara.DeleteRidershipAccountRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteRidershipAccount(request, requestOptions));
    }

    private async __deleteRidershipAccount(
        request: Samsara.DeleteRidershipAccountRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const { id } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/accounts",
            ),
            method: "DELETE",
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/ridership/accounts");
    }

    /**
     * Get a single ridership account by ID. The ID can be a Samsara UUID or an external ID in `key:value` format.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetRidershipAccountRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getRidershipAccount({
     *         id: "id"
     *     })
     */
    public getRidershipAccount(
        request: Samsara.GetRidershipAccountRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipAccountsGetRidershipAccountResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getRidershipAccount(request, requestOptions));
    }

    private async __getRidershipAccount(
        request: Samsara.GetRidershipAccountRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipAccountsGetRidershipAccountResponseBody>> {
        const { id, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `ridership/accounts/${core.url.encodePathParam(id)}`,
            ),
            method: "GET",
            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 Samsara.RidershipAccountsGetRidershipAccountResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/ridership/accounts/{id}");
    }

    /**
     * List ridership passengers for an account.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListRidershipPassengersRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listRidershipPassengers({
     *         accountId: "accountId"
     *     })
     */
    public listRidershipPassengers(
        request: Samsara.ListRidershipPassengersRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipPassengersListRidershipPassengersResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listRidershipPassengers(request, requestOptions));
    }

    private async __listRidershipPassengers(
        request: Samsara.ListRidershipPassengersRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipPassengersListRidershipPassengersResponseBody>> {
        const { accountId, after, limit, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            accountId,
            after,
            limit,
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/passengers",
            ),
            method: "GET",
            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 Samsara.RidershipPassengersListRidershipPassengersResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/ridership/passengers");
    }

    /**
     * Create a new ridership passenger.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipPassengersCreateRidershipPassengerRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createRidershipPassenger({
     *         accountId: "e4b2c3a5-7d6f-4e8b-9a0c-1b2d3e4f5a6b",
     *         firstName: "John",
     *         lastName: "Doe"
     *     })
     */
    public createRidershipPassenger(
        request: Samsara.RidershipPassengersCreateRidershipPassengerRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipPassengersCreateRidershipPassengerResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createRidershipPassenger(request, requestOptions));
    }

    private async __createRidershipPassenger(
        request: Samsara.RidershipPassengersCreateRidershipPassengerRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipPassengersCreateRidershipPassengerResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/passengers",
            ),
            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 Samsara.RidershipPassengersCreateRidershipPassengerResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/ridership/passengers");
    }

    /**
     * Update a ridership passenger by Samsara ID. All provided fields will overwrite existing values (PUT semantics).
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipPassengersUpdateRidershipPassengerRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.updateRidershipPassenger({
     *         id: "id",
     *         accountId: "e4b2c3a5-7d6f-4e8b-9a0c-1b2d3e4f5a6b",
     *         firstName: "John",
     *         lastName: "Doe"
     *     })
     */
    public updateRidershipPassenger(
        request: Samsara.RidershipPassengersUpdateRidershipPassengerRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipPassengersUpdateRidershipPassengerResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__updateRidershipPassenger(request, requestOptions));
    }

    private async __updateRidershipPassenger(
        request: Samsara.RidershipPassengersUpdateRidershipPassengerRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipPassengersUpdateRidershipPassengerResponseBody>> {
        const { id, ..._body } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/passengers",
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...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 Samsara.RidershipPassengersUpdateRidershipPassengerResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/ridership/passengers");
    }

    /**
     * Delete a ridership passenger by Samsara ID.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeleteRidershipPassengerRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.deleteRidershipPassenger({
     *         id: "id"
     *     })
     */
    public deleteRidershipPassenger(
        request: Samsara.DeleteRidershipPassengerRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteRidershipPassenger(request, requestOptions));
    }

    private async __deleteRidershipPassenger(
        request: Samsara.DeleteRidershipPassengerRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const { id } = request;
        const _queryParams: Record<string, unknown> = {
            id,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/passengers",
            ),
            method: "DELETE",
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/ridership/passengers");
    }

    /**
     * Get a single ridership passenger by ID. The ID can be a Samsara UUID or an external ID in `key:value` format.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetRidershipPassengerRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getRidershipPassenger({
     *         id: "id"
     *     })
     */
    public getRidershipPassenger(
        request: Samsara.GetRidershipPassengerRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipPassengersGetRidershipPassengerResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getRidershipPassenger(request, requestOptions));
    }

    private async __getRidershipPassenger(
        request: Samsara.GetRidershipPassengerRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipPassengersGetRidershipPassengerResponseBody>> {
        const { id, includeExternalIds } = request;
        const _queryParams: Record<string, unknown> = {
            includeExternalIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `ridership/passengers/${core.url.encodePathParam(id)}`,
            ),
            method: "GET",
            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 Samsara.RidershipPassengersGetRidershipPassengerResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/ridership/passengers/{id}");
    }

    /**
     * List all route setups for a ridership account.
     *
     *  <b>Rate limit:</b> 5 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.ListRidershipRouteSetupsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.listRidershipRouteSetups({
     *         accountId: "accountId"
     *     })
     */
    public listRidershipRouteSetups(
        request: Samsara.ListRidershipRouteSetupsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipRouteSetupsListRidershipRouteSetupsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__listRidershipRouteSetups(request, requestOptions));
    }

    private async __listRidershipRouteSetups(
        request: Samsara.ListRidershipRouteSetupsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipRouteSetupsListRidershipRouteSetupsResponseBody>> {
        const { accountId, after, limit } = request;
        const _queryParams: Record<string, unknown> = {
            accountId,
            after,
            limit,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/route-setups",
            ),
            method: "GET",
            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 Samsara.RidershipRouteSetupsListRidershipRouteSetupsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/ridership/route-setups");
    }

    /**
     * Create the passenger assignment setup for a route.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipRouteSetupsCreateRidershipRouteSetupRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.createRidershipRouteSetup({
     *         accountId: "e4b2c3a5-7d6f-4e8b-9a0c-1b2d3e4f5a6b",
     *         passengers: [{
     *                 passengerId: "a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d"
     *             }],
     *         routeId: "123456"
     *     })
     */
    public createRidershipRouteSetup(
        request: Samsara.RidershipRouteSetupsCreateRidershipRouteSetupRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipRouteSetupsCreateRidershipRouteSetupResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__createRidershipRouteSetup(request, requestOptions));
    }

    private async __createRidershipRouteSetup(
        request: Samsara.RidershipRouteSetupsCreateRidershipRouteSetupRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipRouteSetupsCreateRidershipRouteSetupResponseBody>> {
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/route-setups",
            ),
            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 Samsara.RidershipRouteSetupsCreateRidershipRouteSetupResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "POST", "/ridership/route-setups");
    }

    /**
     * Update (replace) the passenger assignment setup for a route. All existing assignments will be replaced with the provided assignments.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupRequestBody} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.updateRidershipRouteSetup({
     *         routeId: "routeId",
     *         accountId: "e4b2c3a5-7d6f-4e8b-9a0c-1b2d3e4f5a6b",
     *         passengers: [{
     *                 passengerId: "a1b2c3d4-5e6f-7a8b-9c0d-1e2f3a4b5c6d"
     *             }]
     *     })
     */
    public updateRidershipRouteSetup(
        request: Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__updateRidershipRouteSetup(request, requestOptions));
    }

    private async __updateRidershipRouteSetup(
        request: Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupRequestBody,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupResponseBody>> {
        const { routeId, ..._body } = request;
        const _queryParams: Record<string, unknown> = {
            routeId,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/route-setups",
            ),
            method: "PUT",
            headers: _headers,
            contentType: "application/json",
            queryParameters: { ..._queryParams, ...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 Samsara.RidershipRouteSetupsUpdateRidershipRouteSetupResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "PUT", "/ridership/route-setups");
    }

    /**
     * Delete the passenger assignment setup for a route.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Write Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.DeleteRidershipRouteSetupRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.deleteRidershipRouteSetup({
     *         routeId: "routeId"
     *     })
     */
    public deleteRidershipRouteSetup(
        request: Samsara.DeleteRidershipRouteSetupRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<void> {
        return core.HttpResponsePromise.fromPromise(this.__deleteRidershipRouteSetup(request, requestOptions));
    }

    private async __deleteRidershipRouteSetup(
        request: Samsara.DeleteRidershipRouteSetupRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<void>> {
        const { routeId } = request;
        const _queryParams: Record<string, unknown> = {
            routeId,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "ridership/route-setups",
            ),
            method: "DELETE",
            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: undefined, rawResponse: _response.rawResponse };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "DELETE", "/ridership/route-setups");
    }

    /**
     * Get the passenger assignment setup for a route by route ID.
     *
     *  <b>Rate limit:</b> 10 requests/sec (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Ridership** under the Ridership category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetRidershipRouteSetupRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getRidershipRouteSetup({
     *         routeId: "routeId"
     *     })
     */
    public getRidershipRouteSetup(
        request: Samsara.GetRidershipRouteSetupRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.RidershipRouteSetupsGetRidershipRouteSetupResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getRidershipRouteSetup(request, requestOptions));
    }

    private async __getRidershipRouteSetup(
        request: Samsara.GetRidershipRouteSetupRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.RidershipRouteSetupsGetRidershipRouteSetupResponseBody>> {
        const { routeId } = request;
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                `ridership/route-setups/${core.url.encodePathParam(routeId)}`,
            ),
            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 Samsara.RidershipRouteSetupsGetRidershipRouteSetupResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(
            _response.error,
            _response.rawResponse,
            "GET",
            "/ridership/route-setups/{routeId}",
        );
    }

    /**
     * Get safety scores and overall risk factors for drivers.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDriverSafetyScoresRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDriverSafetyScores({
     *         endTime: "endTime",
     *         startTime: "startTime"
     *     })
     */
    public getDriverSafetyScores(
        request: Samsara.GetDriverSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetDriverSafetyScoresResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDriverSafetyScores(request, requestOptions));
    }

    private async __getDriverSafetyScores(
        request: Samsara.GetDriverSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetDriverSafetyScoresResponseBody>> {
        const { endTime, startTime, driverIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            driverIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/drivers",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetDriverSafetyScoresResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/drivers");
    }

    /**
     * Get trips contributing to a driver's safety score, and risk factors in each trip.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetDriverSafetyScoreTripsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getDriverSafetyScoreTrips({
     *         endTime: "endTime",
     *         startTime: "startTime"
     *     })
     */
    public getDriverSafetyScoreTrips(
        request: Samsara.GetDriverSafetyScoreTripsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetDriverSafetyScoreTripsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getDriverSafetyScoreTrips(request, requestOptions));
    }

    private async __getDriverSafetyScoreTrips(
        request: Samsara.GetDriverSafetyScoreTripsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetDriverSafetyScoreTripsResponseBody>> {
        const { endTime, startTime, driverIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            driverIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/drivers/trips",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetDriverSafetyScoreTripsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/drivers/trips");
    }

    /**
     * Get a combined safety score and risk factors for a set of tags.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetTagGroupSafetyScoresRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getTagGroupSafetyScores({
     *         endTime: "endTime",
     *         startTime: "startTime",
     *         scoreType: "driver"
     *     })
     */
    public getTagGroupSafetyScores(
        request: Samsara.GetTagGroupSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetTagGroupSafetyScoresResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getTagGroupSafetyScores(request, requestOptions));
    }

    private async __getTagGroupSafetyScores(
        request: Samsara.GetTagGroupSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetTagGroupSafetyScoresResponseBody>> {
        const { endTime, startTime, scoreType, tagIds } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            scoreType,
            tagIds,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/tag-group",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetTagGroupSafetyScoresResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/tag-group");
    }

    /**
     * Get safety scores and overall risk factors for tags.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetTagSafetyScoresRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getTagSafetyScores({
     *         endTime: "endTime",
     *         startTime: "startTime",
     *         scoreType: "driver"
     *     })
     */
    public getTagSafetyScores(
        request: Samsara.GetTagSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetTagSafetyScoresResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getTagSafetyScores(request, requestOptions));
    }

    private async __getTagSafetyScores(
        request: Samsara.GetTagSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetTagSafetyScoresResponseBody>> {
        const { endTime, startTime, scoreType, tagIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            scoreType,
            tagIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/tags",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetTagSafetyScoresResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/tags");
    }

    /**
     * Get safety scores and overall risk factors for vehicles.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetVehicleSafetyScoresRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getVehicleSafetyScores({
     *         endTime: "endTime",
     *         startTime: "startTime"
     *     })
     */
    public getVehicleSafetyScores(
        request: Samsara.GetVehicleSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetVehicleSafetyScoresResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getVehicleSafetyScores(request, requestOptions));
    }

    private async __getVehicleSafetyScores(
        request: Samsara.GetVehicleSafetyScoresRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetVehicleSafetyScoresResponseBody>> {
        const { endTime, startTime, vehicleIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            vehicleIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/vehicles",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetVehicleSafetyScoresResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/vehicles");
    }

    /**
     * Get trips contributing to a vehicle's safety score, and risk factors in each trip.
     *
     *  <b>Rate limit:</b> 100 requests/min (learn more about rate limits <a href="https://developers.samsara.com/docs/rate-limits" target="_blank">here</a>).
     *
     * To use this endpoint, select **Read Safety Events & Scores** under the Safety & Cameras category when creating or editing an API token. <a href="https://developers.samsara.com/docs/authentication#scopes-for-api-tokens" target="_blank">Learn More.</a>
     *
     *
     *  **Submit Feedback**: Likes, dislikes, and API feature requests should be filed as feedback in our <a href="https://forms.gle/zkD4NCH7HjKb7mm69" target="_blank">API feedback form</a>. If you encountered an issue or noticed inaccuracies in the API documentation, please <a href="https://www.samsara.com/help" target="_blank">submit a case</a> to our support team.
     *
     * @param {Samsara.GetVehicleSafetyScoreTripsRequest} request
     * @param {BetaApIsClient.RequestOptions} requestOptions - Request-specific configuration.
     *
     * @throws {@link Samsara.UnauthorizedError}
     * @throws {@link Samsara.NotFoundError}
     * @throws {@link Samsara.MethodNotAllowedError}
     * @throws {@link Samsara.TooManyRequestsError}
     * @throws {@link Samsara.InternalServerError}
     * @throws {@link Samsara.NotImplementedError}
     * @throws {@link Samsara.BadGatewayError}
     * @throws {@link Samsara.ServiceUnavailableError}
     * @throws {@link Samsara.GatewayTimeoutError}
     *
     * @example
     *     await client.betaApIs.getVehicleSafetyScoreTrips({
     *         endTime: "endTime",
     *         startTime: "startTime"
     *     })
     */
    public getVehicleSafetyScoreTrips(
        request: Samsara.GetVehicleSafetyScoreTripsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): core.HttpResponsePromise<Samsara.SafetyScoresGetVehicleSafetyScoreTripsResponseBody> {
        return core.HttpResponsePromise.fromPromise(this.__getVehicleSafetyScoreTrips(request, requestOptions));
    }

    private async __getVehicleSafetyScoreTrips(
        request: Samsara.GetVehicleSafetyScoreTripsRequest,
        requestOptions?: BetaApIsClient.RequestOptions,
    ): Promise<core.WithRawResponse<Samsara.SafetyScoresGetVehicleSafetyScoreTripsResponseBody>> {
        const { endTime, startTime, vehicleIds, after } = request;
        const _queryParams: Record<string, unknown> = {
            endTime,
            startTime,
            vehicleIds,
            after,
        };
        const _authRequest: core.AuthRequest = await this._options.authProvider.getAuthRequest();
        const _headers: core.Fetcher.Args["headers"] = mergeHeaders(
            _authRequest.headers,
            this._options?.headers,
            mergeOnlyDefinedHeaders({ "X-Samsara-Version": requestOptions?.version }),
            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.SamsaraEnvironment.ProductionApi,
                "safety-scores/vehicles/trips",
            ),
            method: "GET",
            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 Samsara.SafetyScoresGetVehicleSafetyScoreTripsResponseBody,
                rawResponse: _response.rawResponse,
            };
        }

        if (_response.error.reason === "status-code") {
            switch (_response.error.statusCode) {
                case 401:
                    throw new Samsara.UnauthorizedError(_response.error.body as unknown, _response.rawResponse);
                case 404:
                    throw new Samsara.NotFoundError(_response.error.body as unknown, _response.rawResponse);
                case 405:
                    throw new Samsara.MethodNotAllowedError(_response.error.body as unknown, _response.rawResponse);
                case 429:
                    throw new Samsara.TooManyRequestsError(_response.error.body as unknown, _response.rawResponse);
                case 500:
                    throw new Samsara.InternalServerError(_response.error.body as unknown, _response.rawResponse);
                case 501:
                    throw new Samsara.NotImplementedError(_response.error.body as unknown, _response.rawResponse);
                case 502:
                    throw new Samsara.BadGatewayError(_response.error.body as unknown, _response.rawResponse);
                case 503:
                    throw new Samsara.ServiceUnavailableError(_response.error.body as unknown, _response.rawResponse);
                case 504:
                    throw new Samsara.GatewayTimeoutError(_response.error.body as unknown, _response.rawResponse);
                default:
                    throw new errors.SamsaraError({
                        statusCode: _response.error.statusCode,
                        body: _response.error.body,
                        rawResponse: _response.rawResponse,
                    });
            }
        }

        return handleNonStatusCodeError(_response.error, _response.rawResponse, "GET", "/safety-scores/vehicles/trips");
    }
}