export * from '@seamapi/url-search-params-serializer';
import { RouteRequestBody, RouteResponse, RouteRequestParams, ActionAttempt, openapi } from '@seamapi/types/connect';
import { AxiosRequestConfig, AxiosInstance, Method } from 'axios';
import { AxiosRetry } from 'axios-retry';

type Client = AxiosInstance;
interface ClientOptions {
    axiosOptions?: AxiosRequestConfig;
    axiosRetryOptions?: AxiosRetryConfig;
}
type AxiosRetryConfig = Parameters<AxiosRetry>[1];

interface SeamHttpRequestParent {
    readonly client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
}
interface SeamHttpRequestConfig<TResponseKey> {
    readonly pathname: string;
    readonly method: Method;
    readonly body?: unknown;
    readonly params?: undefined | Record<string, unknown>;
    readonly responseKey: TResponseKey;
    readonly options?: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
}
declare class SeamHttpRequest<const TResponse, const TResponseKey extends keyof TResponse | undefined> implements Promise<TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined> {
    #private;
    readonly [Symbol.toStringTag]: string;
    constructor(parent: SeamHttpRequestParent, config: SeamHttpRequestConfig<TResponseKey>);
    get responseKey(): TResponseKey;
    get url(): URL;
    get pathname(): string;
    get method(): Method;
    get params(): undefined | Record<string, unknown>;
    get body(): unknown;
    execute(): Promise<TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined>;
    fetchResponse(): Promise<TResponse>;
    then<TResult1 = TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined, TResult2 = never>(onfulfilled?: ((value: TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined): Promise<(TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined) | TResult>;
    finally(onfinally?: (() => void) | null | undefined): Promise<TResponseKey extends keyof TResponse ? TResponse[TResponseKey] : undefined>;
}

interface SeamPaginatorParent {
    readonly client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
}
declare const $brand: unique symbol;
type SeamPageCursor = string & {
    [$brand]: 'SeamPageCursor';
};
interface Pagination {
    readonly hasNextPage: boolean;
    readonly nextPageCursor: SeamPageCursor | null;
    readonly nextPageUrl: string | null;
}
declare class SeamPaginator<const TResponse, const TResponseKey extends keyof TResponse> implements AsyncIterable<EnsureReadonlyArray<TResponse[TResponseKey]>> {
    #private;
    constructor(parent: SeamPaginatorParent, request: SeamHttpRequest<TResponse, TResponseKey>);
    firstPage(): Promise<[
        EnsureReadonlyArray<TResponse[TResponseKey]>,
        Pagination
    ]>;
    nextPage(nextPageCursor: Pagination['nextPageCursor']): Promise<[EnsureReadonlyArray<TResponse[TResponseKey]>, Pagination]>;
    flattenToArray(): Promise<EnsureReadonlyArray<TResponse[TResponseKey]>>;
    flatten(): AsyncGenerator<EnsureReadonlyArray<TResponse[TResponseKey]>>;
    [Symbol.asyncIterator](): AsyncGenerator<EnsureReadonlyArray<TResponse[TResponseKey]>>;
}
type EnsureReadonlyArray<T> = T extends readonly any[] ? T : never;

type SetNonNullable<BaseType, Keys extends keyof BaseType = keyof BaseType> = {
    [Key in keyof BaseType]: Key extends Keys ? NonNullable<BaseType[Key]> : BaseType[Key];
};

declare class SeamHttpAccessCodesSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessCodesSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessCodesSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessCodesSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessCodesSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessCodesSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessCodesSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    createUnmanagedAccessCode(parameters?: AccessCodesSimulateCreateUnmanagedAccessCodeParameters, options?: AccessCodesSimulateCreateUnmanagedAccessCodeOptions): AccessCodesSimulateCreateUnmanagedAccessCodeRequest;
}
type AccessCodesSimulateCreateUnmanagedAccessCodeParameters = RouteRequestBody<'/access_codes/simulate/create_unmanaged_access_code'>;
/**
 * @deprecated Use AccessCodesSimulateCreateUnmanagedAccessCodeParameters instead.
 */
type AccessCodesSimulateCreateUnmanagedAccessCodeBody = AccessCodesSimulateCreateUnmanagedAccessCodeParameters;
/**
 * @deprecated Use AccessCodesSimulateCreateUnmanagedAccessCodeRequest instead.
 */
type AccessCodesSimulateCreateUnmanagedAccessCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/simulate/create_unmanaged_access_code'>>>;
type AccessCodesSimulateCreateUnmanagedAccessCodeRequest = SeamHttpRequest<AccessCodesSimulateCreateUnmanagedAccessCodeResponse, 'access_code'>;
interface AccessCodesSimulateCreateUnmanagedAccessCodeOptions {
}

declare class SeamHttpAccessCodesUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessCodesUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessCodesUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessCodesUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessCodesUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessCodesUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessCodesUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    convertToManaged(parameters?: AccessCodesUnmanagedConvertToManagedParameters, options?: AccessCodesUnmanagedConvertToManagedOptions): AccessCodesUnmanagedConvertToManagedRequest;
    delete(parameters?: AccessCodesUnmanagedDeleteParameters, options?: AccessCodesUnmanagedDeleteOptions): AccessCodesUnmanagedDeleteRequest;
    get(parameters?: AccessCodesUnmanagedGetParameters, options?: AccessCodesUnmanagedGetOptions): AccessCodesUnmanagedGetRequest;
    list(parameters?: AccessCodesUnmanagedListParameters, options?: AccessCodesUnmanagedListOptions): AccessCodesUnmanagedListRequest;
    update(parameters?: AccessCodesUnmanagedUpdateParameters, options?: AccessCodesUnmanagedUpdateOptions): AccessCodesUnmanagedUpdateRequest;
}
type AccessCodesUnmanagedConvertToManagedParameters = RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>;
/**
 * @deprecated Use AccessCodesUnmanagedConvertToManagedParameters instead.
 */
type AccessCodesUnmanagedConvertToManagedBody = AccessCodesUnmanagedConvertToManagedParameters;
/**
 * @deprecated Use AccessCodesUnmanagedConvertToManagedRequest instead.
 */
type AccessCodesUnmanagedConvertToManagedResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/convert_to_managed'>>>;
type AccessCodesUnmanagedConvertToManagedRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesUnmanagedConvertToManagedOptions {
}
type AccessCodesUnmanagedDeleteParameters = RouteRequestBody<'/access_codes/unmanaged/delete'>;
/**
 * @deprecated Use AccessCodesUnmanagedDeleteParameters instead.
 */
type AccessCodesUnmanagedDeleteParams = AccessCodesUnmanagedDeleteParameters;
/**
 * @deprecated Use AccessCodesUnmanagedDeleteRequest instead.
 */
type AccessCodesUnmanagedDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/delete'>>>;
type AccessCodesUnmanagedDeleteRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesUnmanagedDeleteOptions {
}
type AccessCodesUnmanagedGetParameters = RouteRequestBody<'/access_codes/unmanaged/get'>;
/**
 * @deprecated Use AccessCodesUnmanagedGetParameters instead.
 */
type AccessCodesUnmanagedGetParams = AccessCodesUnmanagedGetParameters;
/**
 * @deprecated Use AccessCodesUnmanagedGetRequest instead.
 */
type AccessCodesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/get'>>>;
type AccessCodesUnmanagedGetRequest = SeamHttpRequest<AccessCodesUnmanagedGetResponse, 'access_code'>;
interface AccessCodesUnmanagedGetOptions {
}
type AccessCodesUnmanagedListParameters = RouteRequestBody<'/access_codes/unmanaged/list'>;
/**
 * @deprecated Use AccessCodesUnmanagedListParameters instead.
 */
type AccessCodesUnmanagedListParams = AccessCodesUnmanagedListParameters;
/**
 * @deprecated Use AccessCodesUnmanagedListRequest instead.
 */
type AccessCodesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/list'>>>;
type AccessCodesUnmanagedListRequest = SeamHttpRequest<AccessCodesUnmanagedListResponse, 'access_codes'>;
interface AccessCodesUnmanagedListOptions {
}
type AccessCodesUnmanagedUpdateParameters = RouteRequestBody<'/access_codes/unmanaged/update'>;
/**
 * @deprecated Use AccessCodesUnmanagedUpdateParameters instead.
 */
type AccessCodesUnmanagedUpdateBody = AccessCodesUnmanagedUpdateParameters;
/**
 * @deprecated Use AccessCodesUnmanagedUpdateRequest instead.
 */
type AccessCodesUnmanagedUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/update'>>>;
type AccessCodesUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesUnmanagedUpdateOptions {
}

declare class SeamHttpAccessCodes {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessCodes;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessCodes;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessCodes;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessCodes>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessCodes;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessCodes;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpAccessCodesSimulate;
    get unmanaged(): SeamHttpAccessCodesUnmanaged;
    create(parameters?: AccessCodesCreateParameters, options?: AccessCodesCreateOptions): AccessCodesCreateRequest;
    createMultiple(parameters?: AccessCodesCreateMultipleParameters, options?: AccessCodesCreateMultipleOptions): AccessCodesCreateMultipleRequest;
    delete(parameters?: AccessCodesDeleteParameters, options?: AccessCodesDeleteOptions): AccessCodesDeleteRequest;
    generateCode(parameters?: AccessCodesGenerateCodeParameters, options?: AccessCodesGenerateCodeOptions): AccessCodesGenerateCodeRequest;
    get(parameters?: AccessCodesGetParameters, options?: AccessCodesGetOptions): AccessCodesGetRequest;
    getTimeline(parameters?: AccessCodesGetTimelineParameters, options?: AccessCodesGetTimelineOptions): AccessCodesGetTimelineRequest;
    list(parameters?: AccessCodesListParameters, options?: AccessCodesListOptions): AccessCodesListRequest;
    pullBackupAccessCode(parameters?: AccessCodesPullBackupAccessCodeParameters, options?: AccessCodesPullBackupAccessCodeOptions): AccessCodesPullBackupAccessCodeRequest;
    reportDeviceConstraints(parameters?: AccessCodesReportDeviceConstraintsParameters, options?: AccessCodesReportDeviceConstraintsOptions): AccessCodesReportDeviceConstraintsRequest;
    update(parameters?: AccessCodesUpdateParameters, options?: AccessCodesUpdateOptions): AccessCodesUpdateRequest;
    updateMultiple(parameters?: AccessCodesUpdateMultipleParameters, options?: AccessCodesUpdateMultipleOptions): AccessCodesUpdateMultipleRequest;
}
type AccessCodesCreateParameters = RouteRequestBody<'/access_codes/create'>;
/**
 * @deprecated Use AccessCodesCreateParameters instead.
 */
type AccessCodesCreateBody = AccessCodesCreateParameters;
/**
 * @deprecated Use AccessCodesCreateRequest instead.
 */
type AccessCodesCreateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create'>>>;
type AccessCodesCreateRequest = SeamHttpRequest<AccessCodesCreateResponse, 'access_code'>;
interface AccessCodesCreateOptions {
}
type AccessCodesCreateMultipleParameters = RouteRequestBody<'/access_codes/create_multiple'>;
/**
 * @deprecated Use AccessCodesCreateMultipleParameters instead.
 */
type AccessCodesCreateMultipleBody = AccessCodesCreateMultipleParameters;
/**
 * @deprecated Use AccessCodesCreateMultipleRequest instead.
 */
type AccessCodesCreateMultipleResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create_multiple'>>>;
type AccessCodesCreateMultipleRequest = SeamHttpRequest<AccessCodesCreateMultipleResponse, 'access_codes'>;
interface AccessCodesCreateMultipleOptions {
}
type AccessCodesDeleteParameters = RouteRequestBody<'/access_codes/delete'>;
/**
 * @deprecated Use AccessCodesDeleteParameters instead.
 */
type AccessCodesDeleteParams = AccessCodesDeleteParameters;
/**
 * @deprecated Use AccessCodesDeleteRequest instead.
 */
type AccessCodesDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_codes/delete'>>>;
type AccessCodesDeleteRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesDeleteOptions {
}
type AccessCodesGenerateCodeParameters = RouteRequestBody<'/access_codes/generate_code'>;
/**
 * @deprecated Use AccessCodesGenerateCodeParameters instead.
 */
type AccessCodesGenerateCodeParams = AccessCodesGenerateCodeParameters;
/**
 * @deprecated Use AccessCodesGenerateCodeRequest instead.
 */
type AccessCodesGenerateCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/generate_code'>>>;
type AccessCodesGenerateCodeRequest = SeamHttpRequest<AccessCodesGenerateCodeResponse, 'generated_code'>;
interface AccessCodesGenerateCodeOptions {
}
type AccessCodesGetParameters = RouteRequestBody<'/access_codes/get'>;
/**
 * @deprecated Use AccessCodesGetParameters instead.
 */
type AccessCodesGetParams = AccessCodesGetParameters;
/**
 * @deprecated Use AccessCodesGetRequest instead.
 */
type AccessCodesGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get'>>>;
type AccessCodesGetRequest = SeamHttpRequest<AccessCodesGetResponse, 'access_code'>;
interface AccessCodesGetOptions {
}
type AccessCodesGetTimelineParameters = RouteRequestBody<'/access_codes/get_timeline'>;
/**
 * @deprecated Use AccessCodesGetTimelineParameters instead.
 */
type AccessCodesGetTimelineParams = AccessCodesGetTimelineParameters;
/**
 * @deprecated Use AccessCodesGetTimelineRequest instead.
 */
type AccessCodesGetTimelineResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get_timeline'>>>;
type AccessCodesGetTimelineRequest = SeamHttpRequest<AccessCodesGetTimelineResponse, 'timeline_events'>;
interface AccessCodesGetTimelineOptions {
}
type AccessCodesListParameters = RouteRequestBody<'/access_codes/list'>;
/**
 * @deprecated Use AccessCodesListParameters instead.
 */
type AccessCodesListParams = AccessCodesListParameters;
/**
 * @deprecated Use AccessCodesListRequest instead.
 */
type AccessCodesListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/list'>>>;
type AccessCodesListRequest = SeamHttpRequest<AccessCodesListResponse, 'access_codes'>;
interface AccessCodesListOptions {
}
type AccessCodesPullBackupAccessCodeParameters = RouteRequestBody<'/access_codes/pull_backup_access_code'>;
/**
 * @deprecated Use AccessCodesPullBackupAccessCodeParameters instead.
 */
type AccessCodesPullBackupAccessCodeBody = AccessCodesPullBackupAccessCodeParameters;
/**
 * @deprecated Use AccessCodesPullBackupAccessCodeRequest instead.
 */
type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/pull_backup_access_code'>>>;
type AccessCodesPullBackupAccessCodeRequest = SeamHttpRequest<AccessCodesPullBackupAccessCodeResponse, 'access_code'>;
interface AccessCodesPullBackupAccessCodeOptions {
}
type AccessCodesReportDeviceConstraintsParameters = RouteRequestBody<'/access_codes/report_device_constraints'>;
/**
 * @deprecated Use AccessCodesReportDeviceConstraintsParameters instead.
 */
type AccessCodesReportDeviceConstraintsBody = AccessCodesReportDeviceConstraintsParameters;
/**
 * @deprecated Use AccessCodesReportDeviceConstraintsRequest instead.
 */
type AccessCodesReportDeviceConstraintsResponse = SetNonNullable<Required<RouteResponse<'/access_codes/report_device_constraints'>>>;
type AccessCodesReportDeviceConstraintsRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesReportDeviceConstraintsOptions {
}
type AccessCodesUpdateParameters = RouteRequestBody<'/access_codes/update'>;
/**
 * @deprecated Use AccessCodesUpdateParameters instead.
 */
type AccessCodesUpdateBody = AccessCodesUpdateParameters;
/**
 * @deprecated Use AccessCodesUpdateRequest instead.
 */
type AccessCodesUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/update'>>>;
type AccessCodesUpdateRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesUpdateOptions {
}
type AccessCodesUpdateMultipleParameters = RouteRequestBody<'/access_codes/update_multiple'>;
/**
 * @deprecated Use AccessCodesUpdateMultipleParameters instead.
 */
type AccessCodesUpdateMultipleBody = AccessCodesUpdateMultipleParameters;
/**
 * @deprecated Use AccessCodesUpdateMultipleRequest instead.
 */
type AccessCodesUpdateMultipleResponse = SetNonNullable<Required<RouteResponse<'/access_codes/update_multiple'>>>;
type AccessCodesUpdateMultipleRequest = SeamHttpRequest<void, undefined>;
interface AccessCodesUpdateMultipleOptions {
}

declare class SeamHttpAccessGrantsUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessGrantsUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessGrantsUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessGrantsUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessGrantsUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessGrantsUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessGrantsUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AccessGrantsUnmanagedGetParameters, options?: AccessGrantsUnmanagedGetOptions): AccessGrantsUnmanagedGetRequest;
    list(parameters?: AccessGrantsUnmanagedListParameters, options?: AccessGrantsUnmanagedListOptions): AccessGrantsUnmanagedListRequest;
    update(parameters?: AccessGrantsUnmanagedUpdateParameters, options?: AccessGrantsUnmanagedUpdateOptions): AccessGrantsUnmanagedUpdateRequest;
}
type AccessGrantsUnmanagedGetParameters = RouteRequestBody<'/access_grants/unmanaged/get'>;
/**
 * @deprecated Use AccessGrantsUnmanagedGetParameters instead.
 */
type AccessGrantsUnmanagedGetParams = AccessGrantsUnmanagedGetParameters;
/**
 * @deprecated Use AccessGrantsUnmanagedGetRequest instead.
 */
type AccessGrantsUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_grants/unmanaged/get'>>>;
type AccessGrantsUnmanagedGetRequest = SeamHttpRequest<AccessGrantsUnmanagedGetResponse, 'access_grant'>;
interface AccessGrantsUnmanagedGetOptions {
}
type AccessGrantsUnmanagedListParameters = RouteRequestBody<'/access_grants/unmanaged/list'>;
/**
 * @deprecated Use AccessGrantsUnmanagedListParameters instead.
 */
type AccessGrantsUnmanagedListParams = AccessGrantsUnmanagedListParameters;
/**
 * @deprecated Use AccessGrantsUnmanagedListRequest instead.
 */
type AccessGrantsUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_grants/unmanaged/list'>>>;
type AccessGrantsUnmanagedListRequest = SeamHttpRequest<AccessGrantsUnmanagedListResponse, 'access_grants'>;
interface AccessGrantsUnmanagedListOptions {
}
type AccessGrantsUnmanagedUpdateParameters = RouteRequestBody<'/access_grants/unmanaged/update'>;
/**
 * @deprecated Use AccessGrantsUnmanagedUpdateParameters instead.
 */
type AccessGrantsUnmanagedUpdateBody = AccessGrantsUnmanagedUpdateParameters;
/**
 * @deprecated Use AccessGrantsUnmanagedUpdateRequest instead.
 */
type AccessGrantsUnmanagedUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_grants/unmanaged/update'>>>;
type AccessGrantsUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>;
interface AccessGrantsUnmanagedUpdateOptions {
}

declare class SeamHttpAccessGrants {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessGrants;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessGrants;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessGrants;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessGrants>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessGrants;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessGrants;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get unmanaged(): SeamHttpAccessGrantsUnmanaged;
    create(parameters?: AccessGrantsCreateParameters, options?: AccessGrantsCreateOptions): AccessGrantsCreateRequest;
    delete(parameters?: AccessGrantsDeleteParameters, options?: AccessGrantsDeleteOptions): AccessGrantsDeleteRequest;
    get(parameters?: AccessGrantsGetParameters, options?: AccessGrantsGetOptions): AccessGrantsGetRequest;
    getRelated(parameters?: AccessGrantsGetRelatedParameters, options?: AccessGrantsGetRelatedOptions): AccessGrantsGetRelatedRequest;
    list(parameters?: AccessGrantsListParameters, options?: AccessGrantsListOptions): AccessGrantsListRequest;
    requestAccessMethods(parameters?: AccessGrantsRequestAccessMethodsParameters, options?: AccessGrantsRequestAccessMethodsOptions): AccessGrantsRequestAccessMethodsRequest;
    update(parameters?: AccessGrantsUpdateParameters, options?: AccessGrantsUpdateOptions): AccessGrantsUpdateRequest;
}
type AccessGrantsCreateParameters = RouteRequestBody<'/access_grants/create'>;
/**
 * @deprecated Use AccessGrantsCreateParameters instead.
 */
type AccessGrantsCreateBody = AccessGrantsCreateParameters;
/**
 * @deprecated Use AccessGrantsCreateRequest instead.
 */
type AccessGrantsCreateResponse = SetNonNullable<Required<RouteResponse<'/access_grants/create'>>>;
type AccessGrantsCreateRequest = SeamHttpRequest<AccessGrantsCreateResponse, 'access_grant'>;
interface AccessGrantsCreateOptions {
}
type AccessGrantsDeleteParameters = RouteRequestBody<'/access_grants/delete'>;
/**
 * @deprecated Use AccessGrantsDeleteParameters instead.
 */
type AccessGrantsDeleteParams = AccessGrantsDeleteParameters;
/**
 * @deprecated Use AccessGrantsDeleteRequest instead.
 */
type AccessGrantsDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_grants/delete'>>>;
type AccessGrantsDeleteRequest = SeamHttpRequest<void, undefined>;
interface AccessGrantsDeleteOptions {
}
type AccessGrantsGetParameters = RouteRequestParams<'/access_grants/get'>;
/**
 * @deprecated Use AccessGrantsGetParameters instead.
 */
type AccessGrantsGetParams = AccessGrantsGetParameters;
/**
 * @deprecated Use AccessGrantsGetRequest instead.
 */
type AccessGrantsGetResponse = SetNonNullable<Required<RouteResponse<'/access_grants/get'>>>;
type AccessGrantsGetRequest = SeamHttpRequest<AccessGrantsGetResponse, 'access_grant'>;
interface AccessGrantsGetOptions {
}
type AccessGrantsGetRelatedParameters = RouteRequestBody<'/access_grants/get_related'>;
/**
 * @deprecated Use AccessGrantsGetRelatedParameters instead.
 */
type AccessGrantsGetRelatedParams = AccessGrantsGetRelatedParameters;
/**
 * @deprecated Use AccessGrantsGetRelatedRequest instead.
 */
type AccessGrantsGetRelatedResponse = SetNonNullable<Required<RouteResponse<'/access_grants/get_related'>>>;
type AccessGrantsGetRelatedRequest = SeamHttpRequest<AccessGrantsGetRelatedResponse, 'batch'>;
interface AccessGrantsGetRelatedOptions {
}
type AccessGrantsListParameters = RouteRequestBody<'/access_grants/list'>;
/**
 * @deprecated Use AccessGrantsListParameters instead.
 */
type AccessGrantsListParams = AccessGrantsListParameters;
/**
 * @deprecated Use AccessGrantsListRequest instead.
 */
type AccessGrantsListResponse = SetNonNullable<Required<RouteResponse<'/access_grants/list'>>>;
type AccessGrantsListRequest = SeamHttpRequest<AccessGrantsListResponse, 'access_grants'>;
interface AccessGrantsListOptions {
}
type AccessGrantsRequestAccessMethodsParameters = RouteRequestBody<'/access_grants/request_access_methods'>;
/**
 * @deprecated Use AccessGrantsRequestAccessMethodsParameters instead.
 */
type AccessGrantsRequestAccessMethodsBody = AccessGrantsRequestAccessMethodsParameters;
/**
 * @deprecated Use AccessGrantsRequestAccessMethodsRequest instead.
 */
type AccessGrantsRequestAccessMethodsResponse = SetNonNullable<Required<RouteResponse<'/access_grants/request_access_methods'>>>;
type AccessGrantsRequestAccessMethodsRequest = SeamHttpRequest<AccessGrantsRequestAccessMethodsResponse, 'access_grant'>;
interface AccessGrantsRequestAccessMethodsOptions {
}
type AccessGrantsUpdateParameters = RouteRequestBody<'/access_grants/update'>;
/**
 * @deprecated Use AccessGrantsUpdateParameters instead.
 */
type AccessGrantsUpdateBody = AccessGrantsUpdateParameters;
/**
 * @deprecated Use AccessGrantsUpdateRequest instead.
 */
type AccessGrantsUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_grants/update'>>>;
type AccessGrantsUpdateRequest = SeamHttpRequest<void, undefined>;
interface AccessGrantsUpdateOptions {
}

declare class SeamHttpAccessMethodsUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessMethodsUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessMethodsUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessMethodsUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessMethodsUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessMethodsUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessMethodsUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AccessMethodsUnmanagedGetParameters, options?: AccessMethodsUnmanagedGetOptions): AccessMethodsUnmanagedGetRequest;
    list(parameters?: AccessMethodsUnmanagedListParameters, options?: AccessMethodsUnmanagedListOptions): AccessMethodsUnmanagedListRequest;
}
type AccessMethodsUnmanagedGetParameters = RouteRequestBody<'/access_methods/unmanaged/get'>;
/**
 * @deprecated Use AccessMethodsUnmanagedGetParameters instead.
 */
type AccessMethodsUnmanagedGetParams = AccessMethodsUnmanagedGetParameters;
/**
 * @deprecated Use AccessMethodsUnmanagedGetRequest instead.
 */
type AccessMethodsUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_methods/unmanaged/get'>>>;
type AccessMethodsUnmanagedGetRequest = SeamHttpRequest<AccessMethodsUnmanagedGetResponse, 'access_method'>;
interface AccessMethodsUnmanagedGetOptions {
}
type AccessMethodsUnmanagedListParameters = RouteRequestBody<'/access_methods/unmanaged/list'>;
/**
 * @deprecated Use AccessMethodsUnmanagedListParameters instead.
 */
type AccessMethodsUnmanagedListParams = AccessMethodsUnmanagedListParameters;
/**
 * @deprecated Use AccessMethodsUnmanagedListRequest instead.
 */
type AccessMethodsUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_methods/unmanaged/list'>>>;
type AccessMethodsUnmanagedListRequest = SeamHttpRequest<AccessMethodsUnmanagedListResponse, 'access_methods'>;
interface AccessMethodsUnmanagedListOptions {
}

declare class SeamHttpAccessMethods {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessMethods;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessMethods;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessMethods;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessMethods>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAccessMethods;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAccessMethods;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get unmanaged(): SeamHttpAccessMethodsUnmanaged;
    delete(parameters?: AccessMethodsDeleteParameters, options?: AccessMethodsDeleteOptions): AccessMethodsDeleteRequest;
    encode(parameters?: AccessMethodsEncodeParameters, options?: AccessMethodsEncodeOptions): AccessMethodsEncodeRequest;
    get(parameters?: AccessMethodsGetParameters, options?: AccessMethodsGetOptions): AccessMethodsGetRequest;
    getRelated(parameters?: AccessMethodsGetRelatedParameters, options?: AccessMethodsGetRelatedOptions): AccessMethodsGetRelatedRequest;
    list(parameters?: AccessMethodsListParameters, options?: AccessMethodsListOptions): AccessMethodsListRequest;
}
type AccessMethodsDeleteParameters = RouteRequestParams<'/access_methods/delete'>;
/**
 * @deprecated Use AccessMethodsDeleteParameters instead.
 */
type AccessMethodsDeleteParams = AccessMethodsDeleteParameters;
/**
 * @deprecated Use AccessMethodsDeleteRequest instead.
 */
type AccessMethodsDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_methods/delete'>>>;
type AccessMethodsDeleteRequest = SeamHttpRequest<void, undefined>;
interface AccessMethodsDeleteOptions {
}
type AccessMethodsEncodeParameters = RouteRequestBody<'/access_methods/encode'>;
/**
 * @deprecated Use AccessMethodsEncodeParameters instead.
 */
type AccessMethodsEncodeBody = AccessMethodsEncodeParameters;
/**
 * @deprecated Use AccessMethodsEncodeRequest instead.
 */
type AccessMethodsEncodeResponse = SetNonNullable<Required<RouteResponse<'/access_methods/encode'>>>;
type AccessMethodsEncodeRequest = SeamHttpRequest<AccessMethodsEncodeResponse, 'action_attempt'>;
type AccessMethodsEncodeOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type AccessMethodsGetParameters = RouteRequestBody<'/access_methods/get'>;
/**
 * @deprecated Use AccessMethodsGetParameters instead.
 */
type AccessMethodsGetParams = AccessMethodsGetParameters;
/**
 * @deprecated Use AccessMethodsGetRequest instead.
 */
type AccessMethodsGetResponse = SetNonNullable<Required<RouteResponse<'/access_methods/get'>>>;
type AccessMethodsGetRequest = SeamHttpRequest<AccessMethodsGetResponse, 'access_method'>;
interface AccessMethodsGetOptions {
}
type AccessMethodsGetRelatedParameters = RouteRequestBody<'/access_methods/get_related'>;
/**
 * @deprecated Use AccessMethodsGetRelatedParameters instead.
 */
type AccessMethodsGetRelatedParams = AccessMethodsGetRelatedParameters;
/**
 * @deprecated Use AccessMethodsGetRelatedRequest instead.
 */
type AccessMethodsGetRelatedResponse = SetNonNullable<Required<RouteResponse<'/access_methods/get_related'>>>;
type AccessMethodsGetRelatedRequest = SeamHttpRequest<AccessMethodsGetRelatedResponse, 'batch'>;
interface AccessMethodsGetRelatedOptions {
}
type AccessMethodsListParameters = RouteRequestBody<'/access_methods/list'>;
/**
 * @deprecated Use AccessMethodsListParameters instead.
 */
type AccessMethodsListParams = AccessMethodsListParameters;
/**
 * @deprecated Use AccessMethodsListRequest instead.
 */
type AccessMethodsListResponse = SetNonNullable<Required<RouteResponse<'/access_methods/list'>>>;
type AccessMethodsListRequest = SeamHttpRequest<AccessMethodsListResponse, 'access_methods'>;
interface AccessMethodsListOptions {
}

declare class SeamHttpAcsAccessGroupsUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsAccessGroupsUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsAccessGroupsUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsAccessGroupsUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsAccessGroupsUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsAccessGroupsUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsAccessGroupsUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AcsAccessGroupsUnmanagedGetParameters, options?: AcsAccessGroupsUnmanagedGetOptions): AcsAccessGroupsUnmanagedGetRequest;
    list(parameters?: AcsAccessGroupsUnmanagedListParameters, options?: AcsAccessGroupsUnmanagedListOptions): AcsAccessGroupsUnmanagedListRequest;
}
type AcsAccessGroupsUnmanagedGetParameters = RouteRequestBody<'/acs/access_groups/unmanaged/get'>;
/**
 * @deprecated Use AcsAccessGroupsUnmanagedGetParameters instead.
 */
type AcsAccessGroupsUnmanagedGetParams = AcsAccessGroupsUnmanagedGetParameters;
/**
 * @deprecated Use AcsAccessGroupsUnmanagedGetRequest instead.
 */
type AcsAccessGroupsUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/unmanaged/get'>>>;
type AcsAccessGroupsUnmanagedGetRequest = SeamHttpRequest<AcsAccessGroupsUnmanagedGetResponse, 'acs_access_group'>;
interface AcsAccessGroupsUnmanagedGetOptions {
}
type AcsAccessGroupsUnmanagedListParameters = RouteRequestBody<'/acs/access_groups/unmanaged/list'>;
/**
 * @deprecated Use AcsAccessGroupsUnmanagedListParameters instead.
 */
type AcsAccessGroupsUnmanagedListParams = AcsAccessGroupsUnmanagedListParameters;
/**
 * @deprecated Use AcsAccessGroupsUnmanagedListRequest instead.
 */
type AcsAccessGroupsUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/unmanaged/list'>>>;
type AcsAccessGroupsUnmanagedListRequest = SeamHttpRequest<AcsAccessGroupsUnmanagedListResponse, 'acs_access_groups'>;
interface AcsAccessGroupsUnmanagedListOptions {
}

declare class SeamHttpAcsAccessGroups {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsAccessGroups;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsAccessGroups;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsAccessGroups;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsAccessGroups>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsAccessGroups;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsAccessGroups;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get unmanaged(): SeamHttpAcsAccessGroupsUnmanaged;
    addUser(parameters?: AcsAccessGroupsAddUserParameters, options?: AcsAccessGroupsAddUserOptions): AcsAccessGroupsAddUserRequest;
    delete(parameters?: AcsAccessGroupsDeleteParameters, options?: AcsAccessGroupsDeleteOptions): AcsAccessGroupsDeleteRequest;
    get(parameters?: AcsAccessGroupsGetParameters, options?: AcsAccessGroupsGetOptions): AcsAccessGroupsGetRequest;
    list(parameters?: AcsAccessGroupsListParameters, options?: AcsAccessGroupsListOptions): AcsAccessGroupsListRequest;
    listAccessibleEntrances(parameters?: AcsAccessGroupsListAccessibleEntrancesParameters, options?: AcsAccessGroupsListAccessibleEntrancesOptions): AcsAccessGroupsListAccessibleEntrancesRequest;
    listUsers(parameters?: AcsAccessGroupsListUsersParameters, options?: AcsAccessGroupsListUsersOptions): AcsAccessGroupsListUsersRequest;
    removeUser(parameters?: AcsAccessGroupsRemoveUserParameters, options?: AcsAccessGroupsRemoveUserOptions): AcsAccessGroupsRemoveUserRequest;
}
type AcsAccessGroupsAddUserParameters = RouteRequestBody<'/acs/access_groups/add_user'>;
/**
 * @deprecated Use AcsAccessGroupsAddUserParameters instead.
 */
type AcsAccessGroupsAddUserBody = AcsAccessGroupsAddUserParameters;
/**
 * @deprecated Use AcsAccessGroupsAddUserRequest instead.
 */
type AcsAccessGroupsAddUserResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/add_user'>>>;
type AcsAccessGroupsAddUserRequest = SeamHttpRequest<void, undefined>;
interface AcsAccessGroupsAddUserOptions {
}
type AcsAccessGroupsDeleteParameters = RouteRequestBody<'/acs/access_groups/delete'>;
/**
 * @deprecated Use AcsAccessGroupsDeleteParameters instead.
 */
type AcsAccessGroupsDeleteParams = AcsAccessGroupsDeleteParameters;
/**
 * @deprecated Use AcsAccessGroupsDeleteRequest instead.
 */
type AcsAccessGroupsDeleteResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/delete'>>>;
type AcsAccessGroupsDeleteRequest = SeamHttpRequest<void, undefined>;
interface AcsAccessGroupsDeleteOptions {
}
type AcsAccessGroupsGetParameters = RouteRequestBody<'/acs/access_groups/get'>;
/**
 * @deprecated Use AcsAccessGroupsGetParameters instead.
 */
type AcsAccessGroupsGetParams = AcsAccessGroupsGetParameters;
/**
 * @deprecated Use AcsAccessGroupsGetRequest instead.
 */
type AcsAccessGroupsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/get'>>>;
type AcsAccessGroupsGetRequest = SeamHttpRequest<AcsAccessGroupsGetResponse, 'acs_access_group'>;
interface AcsAccessGroupsGetOptions {
}
type AcsAccessGroupsListParameters = RouteRequestBody<'/acs/access_groups/list'>;
/**
 * @deprecated Use AcsAccessGroupsListParameters instead.
 */
type AcsAccessGroupsListParams = AcsAccessGroupsListParameters;
/**
 * @deprecated Use AcsAccessGroupsListRequest instead.
 */
type AcsAccessGroupsListResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list'>>>;
type AcsAccessGroupsListRequest = SeamHttpRequest<AcsAccessGroupsListResponse, 'acs_access_groups'>;
interface AcsAccessGroupsListOptions {
}
type AcsAccessGroupsListAccessibleEntrancesParameters = RouteRequestBody<'/acs/access_groups/list_accessible_entrances'>;
/**
 * @deprecated Use AcsAccessGroupsListAccessibleEntrancesParameters instead.
 */
type AcsAccessGroupsListAccessibleEntrancesParams = AcsAccessGroupsListAccessibleEntrancesParameters;
/**
 * @deprecated Use AcsAccessGroupsListAccessibleEntrancesRequest instead.
 */
type AcsAccessGroupsListAccessibleEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list_accessible_entrances'>>>;
type AcsAccessGroupsListAccessibleEntrancesRequest = SeamHttpRequest<AcsAccessGroupsListAccessibleEntrancesResponse, 'acs_entrances'>;
interface AcsAccessGroupsListAccessibleEntrancesOptions {
}
type AcsAccessGroupsListUsersParameters = RouteRequestBody<'/acs/access_groups/list_users'>;
/**
 * @deprecated Use AcsAccessGroupsListUsersParameters instead.
 */
type AcsAccessGroupsListUsersParams = AcsAccessGroupsListUsersParameters;
/**
 * @deprecated Use AcsAccessGroupsListUsersRequest instead.
 */
type AcsAccessGroupsListUsersResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list_users'>>>;
type AcsAccessGroupsListUsersRequest = SeamHttpRequest<AcsAccessGroupsListUsersResponse, 'acs_users'>;
interface AcsAccessGroupsListUsersOptions {
}
type AcsAccessGroupsRemoveUserParameters = RouteRequestBody<'/acs/access_groups/remove_user'>;
/**
 * @deprecated Use AcsAccessGroupsRemoveUserParameters instead.
 */
type AcsAccessGroupsRemoveUserParams = AcsAccessGroupsRemoveUserParameters;
/**
 * @deprecated Use AcsAccessGroupsRemoveUserRequest instead.
 */
type AcsAccessGroupsRemoveUserResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/remove_user'>>>;
type AcsAccessGroupsRemoveUserRequest = SeamHttpRequest<void, undefined>;
interface AcsAccessGroupsRemoveUserOptions {
}

declare class SeamHttpAcsCredentialPools {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsCredentialPools;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsCredentialPools;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsCredentialPools;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsCredentialPools>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsCredentialPools;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsCredentialPools;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: AcsCredentialPoolsListParameters, options?: AcsCredentialPoolsListOptions): AcsCredentialPoolsListRequest;
}
type AcsCredentialPoolsListParameters = RouteRequestBody<'/acs/credential_pools/list'>;
/**
 * @deprecated Use AcsCredentialPoolsListParameters instead.
 */
type AcsCredentialPoolsListParams = AcsCredentialPoolsListParameters;
/**
 * @deprecated Use AcsCredentialPoolsListRequest instead.
 */
type AcsCredentialPoolsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credential_pools/list'>>>;
type AcsCredentialPoolsListRequest = SeamHttpRequest<AcsCredentialPoolsListResponse, 'acs_credential_pools'>;
interface AcsCredentialPoolsListOptions {
}

declare class SeamHttpAcsCredentialProvisioningAutomations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsCredentialProvisioningAutomations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsCredentialProvisioningAutomations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsCredentialProvisioningAutomations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsCredentialProvisioningAutomations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsCredentialProvisioningAutomations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsCredentialProvisioningAutomations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    launch(parameters?: AcsCredentialProvisioningAutomationsLaunchParameters, options?: AcsCredentialProvisioningAutomationsLaunchOptions): AcsCredentialProvisioningAutomationsLaunchRequest;
}
type AcsCredentialProvisioningAutomationsLaunchParameters = RouteRequestBody<'/acs/credential_provisioning_automations/launch'>;
/**
 * @deprecated Use AcsCredentialProvisioningAutomationsLaunchParameters instead.
 */
type AcsCredentialProvisioningAutomationsLaunchBody = AcsCredentialProvisioningAutomationsLaunchParameters;
/**
 * @deprecated Use AcsCredentialProvisioningAutomationsLaunchRequest instead.
 */
type AcsCredentialProvisioningAutomationsLaunchResponse = SetNonNullable<Required<RouteResponse<'/acs/credential_provisioning_automations/launch'>>>;
type AcsCredentialProvisioningAutomationsLaunchRequest = SeamHttpRequest<AcsCredentialProvisioningAutomationsLaunchResponse, 'acs_credential_provisioning_automation'>;
interface AcsCredentialProvisioningAutomationsLaunchOptions {
}

declare class SeamHttpAcsCredentialsUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsCredentialsUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsCredentialsUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsCredentialsUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsCredentialsUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsCredentialsUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsCredentialsUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AcsCredentialsUnmanagedGetParameters, options?: AcsCredentialsUnmanagedGetOptions): AcsCredentialsUnmanagedGetRequest;
    list(parameters?: AcsCredentialsUnmanagedListParameters, options?: AcsCredentialsUnmanagedListOptions): AcsCredentialsUnmanagedListRequest;
}
type AcsCredentialsUnmanagedGetParameters = RouteRequestBody<'/acs/credentials/unmanaged/get'>;
/**
 * @deprecated Use AcsCredentialsUnmanagedGetParameters instead.
 */
type AcsCredentialsUnmanagedGetParams = AcsCredentialsUnmanagedGetParameters;
/**
 * @deprecated Use AcsCredentialsUnmanagedGetRequest instead.
 */
type AcsCredentialsUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/unmanaged/get'>>>;
type AcsCredentialsUnmanagedGetRequest = SeamHttpRequest<AcsCredentialsUnmanagedGetResponse, 'acs_credential'>;
interface AcsCredentialsUnmanagedGetOptions {
}
type AcsCredentialsUnmanagedListParameters = RouteRequestParams<'/acs/credentials/unmanaged/list'>;
/**
 * @deprecated Use AcsCredentialsUnmanagedListParameters instead.
 */
type AcsCredentialsUnmanagedListParams = AcsCredentialsUnmanagedListParameters;
/**
 * @deprecated Use AcsCredentialsUnmanagedListRequest instead.
 */
type AcsCredentialsUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/unmanaged/list'>>>;
type AcsCredentialsUnmanagedListRequest = SeamHttpRequest<AcsCredentialsUnmanagedListResponse, 'acs_credentials'>;
interface AcsCredentialsUnmanagedListOptions {
}

declare class SeamHttpAcsCredentials {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsCredentials;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsCredentials;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsCredentials;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsCredentials>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsCredentials;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsCredentials;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get unmanaged(): SeamHttpAcsCredentialsUnmanaged;
    assign(parameters?: AcsCredentialsAssignParameters, options?: AcsCredentialsAssignOptions): AcsCredentialsAssignRequest;
    create(parameters?: AcsCredentialsCreateParameters, options?: AcsCredentialsCreateOptions): AcsCredentialsCreateRequest;
    createOfflineCode(parameters?: AcsCredentialsCreateOfflineCodeParameters, options?: AcsCredentialsCreateOfflineCodeOptions): AcsCredentialsCreateOfflineCodeRequest;
    delete(parameters?: AcsCredentialsDeleteParameters, options?: AcsCredentialsDeleteOptions): AcsCredentialsDeleteRequest;
    get(parameters?: AcsCredentialsGetParameters, options?: AcsCredentialsGetOptions): AcsCredentialsGetRequest;
    list(parameters?: AcsCredentialsListParameters, options?: AcsCredentialsListOptions): AcsCredentialsListRequest;
    listAccessibleEntrances(parameters?: AcsCredentialsListAccessibleEntrancesParameters, options?: AcsCredentialsListAccessibleEntrancesOptions): AcsCredentialsListAccessibleEntrancesRequest;
    unassign(parameters?: AcsCredentialsUnassignParameters, options?: AcsCredentialsUnassignOptions): AcsCredentialsUnassignRequest;
    update(parameters?: AcsCredentialsUpdateParameters, options?: AcsCredentialsUpdateOptions): AcsCredentialsUpdateRequest;
}
type AcsCredentialsAssignParameters = RouteRequestBody<'/acs/credentials/assign'>;
/**
 * @deprecated Use AcsCredentialsAssignParameters instead.
 */
type AcsCredentialsAssignBody = AcsCredentialsAssignParameters;
/**
 * @deprecated Use AcsCredentialsAssignRequest instead.
 */
type AcsCredentialsAssignResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/assign'>>>;
type AcsCredentialsAssignRequest = SeamHttpRequest<void, undefined>;
interface AcsCredentialsAssignOptions {
}
type AcsCredentialsCreateParameters = RouteRequestBody<'/acs/credentials/create'>;
/**
 * @deprecated Use AcsCredentialsCreateParameters instead.
 */
type AcsCredentialsCreateBody = AcsCredentialsCreateParameters;
/**
 * @deprecated Use AcsCredentialsCreateRequest instead.
 */
type AcsCredentialsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/create'>>>;
type AcsCredentialsCreateRequest = SeamHttpRequest<AcsCredentialsCreateResponse, 'acs_credential'>;
interface AcsCredentialsCreateOptions {
}
type AcsCredentialsCreateOfflineCodeParameters = RouteRequestBody<'/acs/credentials/create_offline_code'>;
/**
 * @deprecated Use AcsCredentialsCreateOfflineCodeParameters instead.
 */
type AcsCredentialsCreateOfflineCodeBody = AcsCredentialsCreateOfflineCodeParameters;
/**
 * @deprecated Use AcsCredentialsCreateOfflineCodeRequest instead.
 */
type AcsCredentialsCreateOfflineCodeResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/create_offline_code'>>>;
type AcsCredentialsCreateOfflineCodeRequest = SeamHttpRequest<AcsCredentialsCreateOfflineCodeResponse, 'acs_credential'>;
interface AcsCredentialsCreateOfflineCodeOptions {
}
type AcsCredentialsDeleteParameters = RouteRequestBody<'/acs/credentials/delete'>;
/**
 * @deprecated Use AcsCredentialsDeleteParameters instead.
 */
type AcsCredentialsDeleteParams = AcsCredentialsDeleteParameters;
/**
 * @deprecated Use AcsCredentialsDeleteRequest instead.
 */
type AcsCredentialsDeleteResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/delete'>>>;
type AcsCredentialsDeleteRequest = SeamHttpRequest<void, undefined>;
interface AcsCredentialsDeleteOptions {
}
type AcsCredentialsGetParameters = RouteRequestBody<'/acs/credentials/get'>;
/**
 * @deprecated Use AcsCredentialsGetParameters instead.
 */
type AcsCredentialsGetParams = AcsCredentialsGetParameters;
/**
 * @deprecated Use AcsCredentialsGetRequest instead.
 */
type AcsCredentialsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/get'>>>;
type AcsCredentialsGetRequest = SeamHttpRequest<AcsCredentialsGetResponse, 'acs_credential'>;
interface AcsCredentialsGetOptions {
}
type AcsCredentialsListParameters = RouteRequestParams<'/acs/credentials/list'>;
/**
 * @deprecated Use AcsCredentialsListParameters instead.
 */
type AcsCredentialsListParams = AcsCredentialsListParameters;
/**
 * @deprecated Use AcsCredentialsListRequest instead.
 */
type AcsCredentialsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list'>>>;
type AcsCredentialsListRequest = SeamHttpRequest<AcsCredentialsListResponse, 'acs_credentials'>;
interface AcsCredentialsListOptions {
}
type AcsCredentialsListAccessibleEntrancesParameters = RouteRequestBody<'/acs/credentials/list_accessible_entrances'>;
/**
 * @deprecated Use AcsCredentialsListAccessibleEntrancesParameters instead.
 */
type AcsCredentialsListAccessibleEntrancesParams = AcsCredentialsListAccessibleEntrancesParameters;
/**
 * @deprecated Use AcsCredentialsListAccessibleEntrancesRequest instead.
 */
type AcsCredentialsListAccessibleEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list_accessible_entrances'>>>;
type AcsCredentialsListAccessibleEntrancesRequest = SeamHttpRequest<AcsCredentialsListAccessibleEntrancesResponse, 'acs_entrances'>;
interface AcsCredentialsListAccessibleEntrancesOptions {
}
type AcsCredentialsUnassignParameters = RouteRequestBody<'/acs/credentials/unassign'>;
/**
 * @deprecated Use AcsCredentialsUnassignParameters instead.
 */
type AcsCredentialsUnassignBody = AcsCredentialsUnassignParameters;
/**
 * @deprecated Use AcsCredentialsUnassignRequest instead.
 */
type AcsCredentialsUnassignResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/unassign'>>>;
type AcsCredentialsUnassignRequest = SeamHttpRequest<void, undefined>;
interface AcsCredentialsUnassignOptions {
}
type AcsCredentialsUpdateParameters = RouteRequestBody<'/acs/credentials/update'>;
/**
 * @deprecated Use AcsCredentialsUpdateParameters instead.
 */
type AcsCredentialsUpdateBody = AcsCredentialsUpdateParameters;
/**
 * @deprecated Use AcsCredentialsUpdateRequest instead.
 */
type AcsCredentialsUpdateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/update'>>>;
type AcsCredentialsUpdateRequest = SeamHttpRequest<void, undefined>;
interface AcsCredentialsUpdateOptions {
}

declare class SeamHttpAcsEncodersSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsEncodersSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsEncodersSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsEncodersSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsEncodersSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsEncodersSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsEncodersSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    nextCredentialEncodeWillFail(parameters?: AcsEncodersSimulateNextCredentialEncodeWillFailParameters, options?: AcsEncodersSimulateNextCredentialEncodeWillFailOptions): AcsEncodersSimulateNextCredentialEncodeWillFailRequest;
    nextCredentialEncodeWillSucceed(parameters?: AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters, options?: AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions): AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest;
    nextCredentialScanWillFail(parameters?: AcsEncodersSimulateNextCredentialScanWillFailParameters, options?: AcsEncodersSimulateNextCredentialScanWillFailOptions): AcsEncodersSimulateNextCredentialScanWillFailRequest;
    nextCredentialScanWillSucceed(parameters?: AcsEncodersSimulateNextCredentialScanWillSucceedParameters, options?: AcsEncodersSimulateNextCredentialScanWillSucceedOptions): AcsEncodersSimulateNextCredentialScanWillSucceedRequest;
}
type AcsEncodersSimulateNextCredentialEncodeWillFailParameters = RouteRequestBody<'/acs/encoders/simulate/next_credential_encode_will_fail'>;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialEncodeWillFailParameters instead.
 */
type AcsEncodersSimulateNextCredentialEncodeWillFailBody = AcsEncodersSimulateNextCredentialEncodeWillFailParameters;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialEncodeWillFailRequest instead.
 */
type AcsEncodersSimulateNextCredentialEncodeWillFailResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/simulate/next_credential_encode_will_fail'>>>;
type AcsEncodersSimulateNextCredentialEncodeWillFailRequest = SeamHttpRequest<void, undefined>;
interface AcsEncodersSimulateNextCredentialEncodeWillFailOptions {
}
type AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters = RouteRequestBody<'/acs/encoders/simulate/next_credential_encode_will_succeed'>;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters instead.
 */
type AcsEncodersSimulateNextCredentialEncodeWillSucceedBody = AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest instead.
 */
type AcsEncodersSimulateNextCredentialEncodeWillSucceedResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/simulate/next_credential_encode_will_succeed'>>>;
type AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest = SeamHttpRequest<void, undefined>;
interface AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions {
}
type AcsEncodersSimulateNextCredentialScanWillFailParameters = RouteRequestBody<'/acs/encoders/simulate/next_credential_scan_will_fail'>;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialScanWillFailParameters instead.
 */
type AcsEncodersSimulateNextCredentialScanWillFailBody = AcsEncodersSimulateNextCredentialScanWillFailParameters;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialScanWillFailRequest instead.
 */
type AcsEncodersSimulateNextCredentialScanWillFailResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/simulate/next_credential_scan_will_fail'>>>;
type AcsEncodersSimulateNextCredentialScanWillFailRequest = SeamHttpRequest<void, undefined>;
interface AcsEncodersSimulateNextCredentialScanWillFailOptions {
}
type AcsEncodersSimulateNextCredentialScanWillSucceedParameters = RouteRequestBody<'/acs/encoders/simulate/next_credential_scan_will_succeed'>;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialScanWillSucceedParameters instead.
 */
type AcsEncodersSimulateNextCredentialScanWillSucceedBody = AcsEncodersSimulateNextCredentialScanWillSucceedParameters;
/**
 * @deprecated Use AcsEncodersSimulateNextCredentialScanWillSucceedRequest instead.
 */
type AcsEncodersSimulateNextCredentialScanWillSucceedResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/simulate/next_credential_scan_will_succeed'>>>;
type AcsEncodersSimulateNextCredentialScanWillSucceedRequest = SeamHttpRequest<void, undefined>;
interface AcsEncodersSimulateNextCredentialScanWillSucceedOptions {
}

declare class SeamHttpAcsEncoders {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsEncoders;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsEncoders;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsEncoders;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsEncoders>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsEncoders;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsEncoders;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpAcsEncodersSimulate;
    encodeCredential(parameters?: AcsEncodersEncodeCredentialParameters, options?: AcsEncodersEncodeCredentialOptions): AcsEncodersEncodeCredentialRequest;
    get(parameters?: AcsEncodersGetParameters, options?: AcsEncodersGetOptions): AcsEncodersGetRequest;
    list(parameters?: AcsEncodersListParameters, options?: AcsEncodersListOptions): AcsEncodersListRequest;
    scanCredential(parameters?: AcsEncodersScanCredentialParameters, options?: AcsEncodersScanCredentialOptions): AcsEncodersScanCredentialRequest;
}
type AcsEncodersEncodeCredentialParameters = RouteRequestBody<'/acs/encoders/encode_credential'>;
/**
 * @deprecated Use AcsEncodersEncodeCredentialParameters instead.
 */
type AcsEncodersEncodeCredentialBody = AcsEncodersEncodeCredentialParameters;
/**
 * @deprecated Use AcsEncodersEncodeCredentialRequest instead.
 */
type AcsEncodersEncodeCredentialResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/encode_credential'>>>;
type AcsEncodersEncodeCredentialRequest = SeamHttpRequest<AcsEncodersEncodeCredentialResponse, 'action_attempt'>;
type AcsEncodersEncodeCredentialOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type AcsEncodersGetParameters = RouteRequestBody<'/acs/encoders/get'>;
/**
 * @deprecated Use AcsEncodersGetParameters instead.
 */
type AcsEncodersGetParams = AcsEncodersGetParameters;
/**
 * @deprecated Use AcsEncodersGetRequest instead.
 */
type AcsEncodersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/get'>>>;
type AcsEncodersGetRequest = SeamHttpRequest<AcsEncodersGetResponse, 'acs_encoder'>;
interface AcsEncodersGetOptions {
}
type AcsEncodersListParameters = RouteRequestParams<'/acs/encoders/list'>;
/**
 * @deprecated Use AcsEncodersListParameters instead.
 */
type AcsEncodersListParams = AcsEncodersListParameters;
/**
 * @deprecated Use AcsEncodersListRequest instead.
 */
type AcsEncodersListResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/list'>>>;
type AcsEncodersListRequest = SeamHttpRequest<AcsEncodersListResponse, 'acs_encoders'>;
interface AcsEncodersListOptions {
}
type AcsEncodersScanCredentialParameters = RouteRequestBody<'/acs/encoders/scan_credential'>;
/**
 * @deprecated Use AcsEncodersScanCredentialParameters instead.
 */
type AcsEncodersScanCredentialBody = AcsEncodersScanCredentialParameters;
/**
 * @deprecated Use AcsEncodersScanCredentialRequest instead.
 */
type AcsEncodersScanCredentialResponse = SetNonNullable<Required<RouteResponse<'/acs/encoders/scan_credential'>>>;
type AcsEncodersScanCredentialRequest = SeamHttpRequest<AcsEncodersScanCredentialResponse, 'action_attempt'>;
type AcsEncodersScanCredentialOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpAcsEntrances {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsEntrances;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsEntrances;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsEntrances;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsEntrances>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsEntrances;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsEntrances;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AcsEntrancesGetParameters, options?: AcsEntrancesGetOptions): AcsEntrancesGetRequest;
    grantAccess(parameters?: AcsEntrancesGrantAccessParameters, options?: AcsEntrancesGrantAccessOptions): AcsEntrancesGrantAccessRequest;
    list(parameters?: AcsEntrancesListParameters, options?: AcsEntrancesListOptions): AcsEntrancesListRequest;
    listCredentialsWithAccess(parameters?: AcsEntrancesListCredentialsWithAccessParameters, options?: AcsEntrancesListCredentialsWithAccessOptions): AcsEntrancesListCredentialsWithAccessRequest;
    unlock(parameters?: AcsEntrancesUnlockParameters, options?: AcsEntrancesUnlockOptions): AcsEntrancesUnlockRequest;
}
type AcsEntrancesGetParameters = RouteRequestBody<'/acs/entrances/get'>;
/**
 * @deprecated Use AcsEntrancesGetParameters instead.
 */
type AcsEntrancesGetParams = AcsEntrancesGetParameters;
/**
 * @deprecated Use AcsEntrancesGetRequest instead.
 */
type AcsEntrancesGetResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/get'>>>;
type AcsEntrancesGetRequest = SeamHttpRequest<AcsEntrancesGetResponse, 'acs_entrance'>;
interface AcsEntrancesGetOptions {
}
type AcsEntrancesGrantAccessParameters = RouteRequestBody<'/acs/entrances/grant_access'>;
/**
 * @deprecated Use AcsEntrancesGrantAccessParameters instead.
 */
type AcsEntrancesGrantAccessBody = AcsEntrancesGrantAccessParameters;
/**
 * @deprecated Use AcsEntrancesGrantAccessRequest instead.
 */
type AcsEntrancesGrantAccessResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/grant_access'>>>;
type AcsEntrancesGrantAccessRequest = SeamHttpRequest<void, undefined>;
interface AcsEntrancesGrantAccessOptions {
}
type AcsEntrancesListParameters = RouteRequestBody<'/acs/entrances/list'>;
/**
 * @deprecated Use AcsEntrancesListParameters instead.
 */
type AcsEntrancesListParams = AcsEntrancesListParameters;
/**
 * @deprecated Use AcsEntrancesListRequest instead.
 */
type AcsEntrancesListResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/list'>>>;
type AcsEntrancesListRequest = SeamHttpRequest<AcsEntrancesListResponse, 'acs_entrances'>;
interface AcsEntrancesListOptions {
}
type AcsEntrancesListCredentialsWithAccessParameters = RouteRequestBody<'/acs/entrances/list_credentials_with_access'>;
/**
 * @deprecated Use AcsEntrancesListCredentialsWithAccessParameters instead.
 */
type AcsEntrancesListCredentialsWithAccessParams = AcsEntrancesListCredentialsWithAccessParameters;
/**
 * @deprecated Use AcsEntrancesListCredentialsWithAccessRequest instead.
 */
type AcsEntrancesListCredentialsWithAccessResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/list_credentials_with_access'>>>;
type AcsEntrancesListCredentialsWithAccessRequest = SeamHttpRequest<AcsEntrancesListCredentialsWithAccessResponse, 'acs_credentials'>;
interface AcsEntrancesListCredentialsWithAccessOptions {
}
type AcsEntrancesUnlockParameters = RouteRequestBody<'/acs/entrances/unlock'>;
/**
 * @deprecated Use AcsEntrancesUnlockParameters instead.
 */
type AcsEntrancesUnlockBody = AcsEntrancesUnlockParameters;
/**
 * @deprecated Use AcsEntrancesUnlockRequest instead.
 */
type AcsEntrancesUnlockResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/unlock'>>>;
type AcsEntrancesUnlockRequest = SeamHttpRequest<AcsEntrancesUnlockResponse, 'action_attempt'>;
type AcsEntrancesUnlockOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpAcsSystems {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsSystems;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsSystems;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsSystems;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsSystems>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsSystems;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsSystems;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AcsSystemsGetParameters, options?: AcsSystemsGetOptions): AcsSystemsGetRequest;
    list(parameters?: AcsSystemsListParameters, options?: AcsSystemsListOptions): AcsSystemsListRequest;
    listCompatibleCredentialManagerAcsSystems(parameters?: AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters, options?: AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions): AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest;
    reportDevices(parameters?: AcsSystemsReportDevicesParameters, options?: AcsSystemsReportDevicesOptions): AcsSystemsReportDevicesRequest;
}
type AcsSystemsGetParameters = RouteRequestBody<'/acs/systems/get'>;
/**
 * @deprecated Use AcsSystemsGetParameters instead.
 */
type AcsSystemsGetParams = AcsSystemsGetParameters;
/**
 * @deprecated Use AcsSystemsGetRequest instead.
 */
type AcsSystemsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/get'>>>;
type AcsSystemsGetRequest = SeamHttpRequest<AcsSystemsGetResponse, 'acs_system'>;
interface AcsSystemsGetOptions {
}
type AcsSystemsListParameters = RouteRequestBody<'/acs/systems/list'>;
/**
 * @deprecated Use AcsSystemsListParameters instead.
 */
type AcsSystemsListParams = AcsSystemsListParameters;
/**
 * @deprecated Use AcsSystemsListRequest instead.
 */
type AcsSystemsListResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list'>>>;
type AcsSystemsListRequest = SeamHttpRequest<AcsSystemsListResponse, 'acs_systems'>;
interface AcsSystemsListOptions {
}
type AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters = RouteRequestBody<'/acs/systems/list_compatible_credential_manager_acs_systems'>;
/**
 * @deprecated Use AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters instead.
 */
type AcsSystemsListCompatibleCredentialManagerAcsSystemsParams = AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters;
/**
 * @deprecated Use AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest instead.
 */
type AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list_compatible_credential_manager_acs_systems'>>>;
type AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest = SeamHttpRequest<AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse, 'acs_systems'>;
interface AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions {
}
type AcsSystemsReportDevicesParameters = RouteRequestBody<'/acs/systems/report_devices'>;
/**
 * @deprecated Use AcsSystemsReportDevicesParameters instead.
 */
type AcsSystemsReportDevicesBody = AcsSystemsReportDevicesParameters;
/**
 * @deprecated Use AcsSystemsReportDevicesRequest instead.
 */
type AcsSystemsReportDevicesResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/report_devices'>>>;
type AcsSystemsReportDevicesRequest = SeamHttpRequest<void, undefined>;
interface AcsSystemsReportDevicesOptions {
}

declare class SeamHttpAcsUsersUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsUsersUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsUsersUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsUsersUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsUsersUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsUsersUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsUsersUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: AcsUsersUnmanagedGetParameters, options?: AcsUsersUnmanagedGetOptions): AcsUsersUnmanagedGetRequest;
    list(parameters?: AcsUsersUnmanagedListParameters, options?: AcsUsersUnmanagedListOptions): AcsUsersUnmanagedListRequest;
}
type AcsUsersUnmanagedGetParameters = RouteRequestBody<'/acs/users/unmanaged/get'>;
/**
 * @deprecated Use AcsUsersUnmanagedGetParameters instead.
 */
type AcsUsersUnmanagedGetParams = AcsUsersUnmanagedGetParameters;
/**
 * @deprecated Use AcsUsersUnmanagedGetRequest instead.
 */
type AcsUsersUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/unmanaged/get'>>>;
type AcsUsersUnmanagedGetRequest = SeamHttpRequest<AcsUsersUnmanagedGetResponse, 'acs_user'>;
interface AcsUsersUnmanagedGetOptions {
}
type AcsUsersUnmanagedListParameters = RouteRequestBody<'/acs/users/unmanaged/list'>;
/**
 * @deprecated Use AcsUsersUnmanagedListParameters instead.
 */
type AcsUsersUnmanagedListParams = AcsUsersUnmanagedListParameters;
/**
 * @deprecated Use AcsUsersUnmanagedListRequest instead.
 */
type AcsUsersUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/acs/users/unmanaged/list'>>>;
type AcsUsersUnmanagedListRequest = SeamHttpRequest<AcsUsersUnmanagedListResponse, 'acs_users'>;
interface AcsUsersUnmanagedListOptions {
}

declare class SeamHttpAcsUsers {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsUsers;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsUsers;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsUsers;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsUsers>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcsUsers;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcsUsers;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get unmanaged(): SeamHttpAcsUsersUnmanaged;
    addToAccessGroup(parameters?: AcsUsersAddToAccessGroupParameters, options?: AcsUsersAddToAccessGroupOptions): AcsUsersAddToAccessGroupRequest;
    create(parameters?: AcsUsersCreateParameters, options?: AcsUsersCreateOptions): AcsUsersCreateRequest;
    delete(parameters?: AcsUsersDeleteParameters, options?: AcsUsersDeleteOptions): AcsUsersDeleteRequest;
    get(parameters?: AcsUsersGetParameters, options?: AcsUsersGetOptions): AcsUsersGetRequest;
    list(parameters?: AcsUsersListParameters, options?: AcsUsersListOptions): AcsUsersListRequest;
    listAccessibleEntrances(parameters?: AcsUsersListAccessibleEntrancesParameters, options?: AcsUsersListAccessibleEntrancesOptions): AcsUsersListAccessibleEntrancesRequest;
    removeFromAccessGroup(parameters?: AcsUsersRemoveFromAccessGroupParameters, options?: AcsUsersRemoveFromAccessGroupOptions): AcsUsersRemoveFromAccessGroupRequest;
    revokeAccessToAllEntrances(parameters?: AcsUsersRevokeAccessToAllEntrancesParameters, options?: AcsUsersRevokeAccessToAllEntrancesOptions): AcsUsersRevokeAccessToAllEntrancesRequest;
    suspend(parameters?: AcsUsersSuspendParameters, options?: AcsUsersSuspendOptions): AcsUsersSuspendRequest;
    unsuspend(parameters?: AcsUsersUnsuspendParameters, options?: AcsUsersUnsuspendOptions): AcsUsersUnsuspendRequest;
    update(parameters?: AcsUsersUpdateParameters, options?: AcsUsersUpdateOptions): AcsUsersUpdateRequest;
}
type AcsUsersAddToAccessGroupParameters = RouteRequestBody<'/acs/users/add_to_access_group'>;
/**
 * @deprecated Use AcsUsersAddToAccessGroupParameters instead.
 */
type AcsUsersAddToAccessGroupBody = AcsUsersAddToAccessGroupParameters;
/**
 * @deprecated Use AcsUsersAddToAccessGroupRequest instead.
 */
type AcsUsersAddToAccessGroupResponse = SetNonNullable<Required<RouteResponse<'/acs/users/add_to_access_group'>>>;
type AcsUsersAddToAccessGroupRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersAddToAccessGroupOptions {
}
type AcsUsersCreateParameters = RouteRequestBody<'/acs/users/create'>;
/**
 * @deprecated Use AcsUsersCreateParameters instead.
 */
type AcsUsersCreateBody = AcsUsersCreateParameters;
/**
 * @deprecated Use AcsUsersCreateRequest instead.
 */
type AcsUsersCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/create'>>>;
type AcsUsersCreateRequest = SeamHttpRequest<AcsUsersCreateResponse, 'acs_user'>;
interface AcsUsersCreateOptions {
}
type AcsUsersDeleteParameters = RouteRequestBody<'/acs/users/delete'>;
/**
 * @deprecated Use AcsUsersDeleteParameters instead.
 */
type AcsUsersDeleteParams = AcsUsersDeleteParameters;
/**
 * @deprecated Use AcsUsersDeleteRequest instead.
 */
type AcsUsersDeleteResponse = SetNonNullable<Required<RouteResponse<'/acs/users/delete'>>>;
type AcsUsersDeleteRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersDeleteOptions {
}
type AcsUsersGetParameters = RouteRequestBody<'/acs/users/get'>;
/**
 * @deprecated Use AcsUsersGetParameters instead.
 */
type AcsUsersGetParams = AcsUsersGetParameters;
/**
 * @deprecated Use AcsUsersGetRequest instead.
 */
type AcsUsersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/get'>>>;
type AcsUsersGetRequest = SeamHttpRequest<AcsUsersGetResponse, 'acs_user'>;
interface AcsUsersGetOptions {
}
type AcsUsersListParameters = RouteRequestBody<'/acs/users/list'>;
/**
 * @deprecated Use AcsUsersListParameters instead.
 */
type AcsUsersListParams = AcsUsersListParameters;
/**
 * @deprecated Use AcsUsersListRequest instead.
 */
type AcsUsersListResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list'>>>;
type AcsUsersListRequest = SeamHttpRequest<AcsUsersListResponse, 'acs_users'>;
interface AcsUsersListOptions {
}
type AcsUsersListAccessibleEntrancesParameters = RouteRequestBody<'/acs/users/list_accessible_entrances'>;
/**
 * @deprecated Use AcsUsersListAccessibleEntrancesParameters instead.
 */
type AcsUsersListAccessibleEntrancesParams = AcsUsersListAccessibleEntrancesParameters;
/**
 * @deprecated Use AcsUsersListAccessibleEntrancesRequest instead.
 */
type AcsUsersListAccessibleEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list_accessible_entrances'>>>;
type AcsUsersListAccessibleEntrancesRequest = SeamHttpRequest<AcsUsersListAccessibleEntrancesResponse, 'acs_entrances'>;
interface AcsUsersListAccessibleEntrancesOptions {
}
type AcsUsersRemoveFromAccessGroupParameters = RouteRequestBody<'/acs/users/remove_from_access_group'>;
/**
 * @deprecated Use AcsUsersRemoveFromAccessGroupParameters instead.
 */
type AcsUsersRemoveFromAccessGroupParams = AcsUsersRemoveFromAccessGroupParameters;
/**
 * @deprecated Use AcsUsersRemoveFromAccessGroupRequest instead.
 */
type AcsUsersRemoveFromAccessGroupResponse = SetNonNullable<Required<RouteResponse<'/acs/users/remove_from_access_group'>>>;
type AcsUsersRemoveFromAccessGroupRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersRemoveFromAccessGroupOptions {
}
type AcsUsersRevokeAccessToAllEntrancesParameters = RouteRequestBody<'/acs/users/revoke_access_to_all_entrances'>;
/**
 * @deprecated Use AcsUsersRevokeAccessToAllEntrancesParameters instead.
 */
type AcsUsersRevokeAccessToAllEntrancesBody = AcsUsersRevokeAccessToAllEntrancesParameters;
/**
 * @deprecated Use AcsUsersRevokeAccessToAllEntrancesRequest instead.
 */
type AcsUsersRevokeAccessToAllEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/users/revoke_access_to_all_entrances'>>>;
type AcsUsersRevokeAccessToAllEntrancesRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersRevokeAccessToAllEntrancesOptions {
}
type AcsUsersSuspendParameters = RouteRequestBody<'/acs/users/suspend'>;
/**
 * @deprecated Use AcsUsersSuspendParameters instead.
 */
type AcsUsersSuspendBody = AcsUsersSuspendParameters;
/**
 * @deprecated Use AcsUsersSuspendRequest instead.
 */
type AcsUsersSuspendResponse = SetNonNullable<Required<RouteResponse<'/acs/users/suspend'>>>;
type AcsUsersSuspendRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersSuspendOptions {
}
type AcsUsersUnsuspendParameters = RouteRequestBody<'/acs/users/unsuspend'>;
/**
 * @deprecated Use AcsUsersUnsuspendParameters instead.
 */
type AcsUsersUnsuspendBody = AcsUsersUnsuspendParameters;
/**
 * @deprecated Use AcsUsersUnsuspendRequest instead.
 */
type AcsUsersUnsuspendResponse = SetNonNullable<Required<RouteResponse<'/acs/users/unsuspend'>>>;
type AcsUsersUnsuspendRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersUnsuspendOptions {
}
type AcsUsersUpdateParameters = RouteRequestBody<'/acs/users/update'>;
/**
 * @deprecated Use AcsUsersUpdateParameters instead.
 */
type AcsUsersUpdateBody = AcsUsersUpdateParameters;
/**
 * @deprecated Use AcsUsersUpdateRequest instead.
 */
type AcsUsersUpdateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/update'>>>;
type AcsUsersUpdateRequest = SeamHttpRequest<void, undefined>;
interface AcsUsersUpdateOptions {
}

declare class SeamHttpAcs {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcs;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcs;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcs;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcs>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpAcs;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpAcs;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get accessGroups(): SeamHttpAcsAccessGroups;
    get credentialPools(): SeamHttpAcsCredentialPools;
    get credentialProvisioningAutomations(): SeamHttpAcsCredentialProvisioningAutomations;
    get credentials(): SeamHttpAcsCredentials;
    get encoders(): SeamHttpAcsEncoders;
    get entrances(): SeamHttpAcsEntrances;
    get systems(): SeamHttpAcsSystems;
    get users(): SeamHttpAcsUsers;
}

declare class SeamHttpActionAttempts {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpActionAttempts;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpActionAttempts;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpActionAttempts;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpActionAttempts>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpActionAttempts;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpActionAttempts;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: ActionAttemptsGetParameters, options?: ActionAttemptsGetOptions): ActionAttemptsGetRequest;
    list(parameters?: ActionAttemptsListParameters, options?: ActionAttemptsListOptions): ActionAttemptsListRequest;
}
type ActionAttemptsGetParameters = RouteRequestBody<'/action_attempts/get'>;
/**
 * @deprecated Use ActionAttemptsGetParameters instead.
 */
type ActionAttemptsGetParams = ActionAttemptsGetParameters;
/**
 * @deprecated Use ActionAttemptsGetRequest instead.
 */
type ActionAttemptsGetResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/get'>>>;
type ActionAttemptsGetRequest = SeamHttpRequest<ActionAttemptsGetResponse, 'action_attempt'>;
type ActionAttemptsGetOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ActionAttemptsListParameters = RouteRequestBody<'/action_attempts/list'>;
/**
 * @deprecated Use ActionAttemptsListParameters instead.
 */
type ActionAttemptsListParams = ActionAttemptsListParameters;
/**
 * @deprecated Use ActionAttemptsListRequest instead.
 */
type ActionAttemptsListResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/list'>>>;
type ActionAttemptsListRequest = SeamHttpRequest<ActionAttemptsListResponse, 'action_attempts'>;
interface ActionAttemptsListOptions {
}

declare class SeamHttpBridges {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpBridges;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpBridges;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpBridges;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpBridges>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpBridges;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpBridges;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: BridgesGetParameters, options?: BridgesGetOptions): BridgesGetRequest;
    list(parameters?: BridgesListParameters, options?: BridgesListOptions): BridgesListRequest;
}
type BridgesGetParameters = RouteRequestBody<'/bridges/get'>;
/**
 * @deprecated Use BridgesGetParameters instead.
 */
type BridgesGetParams = BridgesGetParameters;
/**
 * @deprecated Use BridgesGetRequest instead.
 */
type BridgesGetResponse = SetNonNullable<Required<RouteResponse<'/bridges/get'>>>;
type BridgesGetRequest = SeamHttpRequest<BridgesGetResponse, 'bridge'>;
interface BridgesGetOptions {
}
type BridgesListParameters = RouteRequestBody<'/bridges/list'>;
/**
 * @deprecated Use BridgesListParameters instead.
 */
type BridgesListParams = BridgesListParameters;
/**
 * @deprecated Use BridgesListRequest instead.
 */
type BridgesListResponse = SetNonNullable<Required<RouteResponse<'/bridges/list'>>>;
type BridgesListRequest = SeamHttpRequest<BridgesListResponse, 'bridges'>;
interface BridgesListOptions {
}

declare class SeamHttpClientSessions {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpClientSessions;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpClientSessions;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpClientSessions;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpClientSessions>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpClientSessions;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpClientSessions;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: ClientSessionsCreateParameters, options?: ClientSessionsCreateOptions): ClientSessionsCreateRequest;
    delete(parameters?: ClientSessionsDeleteParameters, options?: ClientSessionsDeleteOptions): ClientSessionsDeleteRequest;
    get(parameters?: ClientSessionsGetParameters, options?: ClientSessionsGetOptions): ClientSessionsGetRequest;
    getOrCreate(parameters?: ClientSessionsGetOrCreateParameters, options?: ClientSessionsGetOrCreateOptions): ClientSessionsGetOrCreateRequest;
    grantAccess(parameters?: ClientSessionsGrantAccessParameters, options?: ClientSessionsGrantAccessOptions): ClientSessionsGrantAccessRequest;
    list(parameters?: ClientSessionsListParameters, options?: ClientSessionsListOptions): ClientSessionsListRequest;
    revoke(parameters?: ClientSessionsRevokeParameters, options?: ClientSessionsRevokeOptions): ClientSessionsRevokeRequest;
}
type ClientSessionsCreateParameters = RouteRequestBody<'/client_sessions/create'>;
/**
 * @deprecated Use ClientSessionsCreateParameters instead.
 */
type ClientSessionsCreateBody = ClientSessionsCreateParameters;
/**
 * @deprecated Use ClientSessionsCreateRequest instead.
 */
type ClientSessionsCreateResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/create'>>>;
type ClientSessionsCreateRequest = SeamHttpRequest<ClientSessionsCreateResponse, 'client_session'>;
interface ClientSessionsCreateOptions {
}
type ClientSessionsDeleteParameters = RouteRequestBody<'/client_sessions/delete'>;
/**
 * @deprecated Use ClientSessionsDeleteParameters instead.
 */
type ClientSessionsDeleteParams = ClientSessionsDeleteParameters;
/**
 * @deprecated Use ClientSessionsDeleteRequest instead.
 */
type ClientSessionsDeleteResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/delete'>>>;
type ClientSessionsDeleteRequest = SeamHttpRequest<void, undefined>;
interface ClientSessionsDeleteOptions {
}
type ClientSessionsGetParameters = RouteRequestBody<'/client_sessions/get'>;
/**
 * @deprecated Use ClientSessionsGetParameters instead.
 */
type ClientSessionsGetParams = ClientSessionsGetParameters;
/**
 * @deprecated Use ClientSessionsGetRequest instead.
 */
type ClientSessionsGetResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get'>>>;
type ClientSessionsGetRequest = SeamHttpRequest<ClientSessionsGetResponse, 'client_session'>;
interface ClientSessionsGetOptions {
}
type ClientSessionsGetOrCreateParameters = RouteRequestBody<'/client_sessions/get_or_create'>;
/**
 * @deprecated Use ClientSessionsGetOrCreateParameters instead.
 */
type ClientSessionsGetOrCreateBody = ClientSessionsGetOrCreateParameters;
/**
 * @deprecated Use ClientSessionsGetOrCreateRequest instead.
 */
type ClientSessionsGetOrCreateResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get_or_create'>>>;
type ClientSessionsGetOrCreateRequest = SeamHttpRequest<ClientSessionsGetOrCreateResponse, 'client_session'>;
interface ClientSessionsGetOrCreateOptions {
}
type ClientSessionsGrantAccessParameters = RouteRequestBody<'/client_sessions/grant_access'>;
/**
 * @deprecated Use ClientSessionsGrantAccessParameters instead.
 */
type ClientSessionsGrantAccessBody = ClientSessionsGrantAccessParameters;
/**
 * @deprecated Use ClientSessionsGrantAccessRequest instead.
 */
type ClientSessionsGrantAccessResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/grant_access'>>>;
type ClientSessionsGrantAccessRequest = SeamHttpRequest<void, undefined>;
interface ClientSessionsGrantAccessOptions {
}
type ClientSessionsListParameters = RouteRequestBody<'/client_sessions/list'>;
/**
 * @deprecated Use ClientSessionsListParameters instead.
 */
type ClientSessionsListParams = ClientSessionsListParameters;
/**
 * @deprecated Use ClientSessionsListRequest instead.
 */
type ClientSessionsListResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/list'>>>;
type ClientSessionsListRequest = SeamHttpRequest<ClientSessionsListResponse, 'client_sessions'>;
interface ClientSessionsListOptions {
}
type ClientSessionsRevokeParameters = RouteRequestBody<'/client_sessions/revoke'>;
/**
 * @deprecated Use ClientSessionsRevokeParameters instead.
 */
type ClientSessionsRevokeBody = ClientSessionsRevokeParameters;
/**
 * @deprecated Use ClientSessionsRevokeRequest instead.
 */
type ClientSessionsRevokeResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/revoke'>>>;
type ClientSessionsRevokeRequest = SeamHttpRequest<void, undefined>;
interface ClientSessionsRevokeOptions {
}

declare class SeamHttpConnectWebviews {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpConnectWebviews;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpConnectWebviews;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpConnectWebviews;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpConnectWebviews>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpConnectWebviews;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpConnectWebviews;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: ConnectWebviewsCreateParameters, options?: ConnectWebviewsCreateOptions): ConnectWebviewsCreateRequest;
    delete(parameters?: ConnectWebviewsDeleteParameters, options?: ConnectWebviewsDeleteOptions): ConnectWebviewsDeleteRequest;
    get(parameters?: ConnectWebviewsGetParameters, options?: ConnectWebviewsGetOptions): ConnectWebviewsGetRequest;
    list(parameters?: ConnectWebviewsListParameters, options?: ConnectWebviewsListOptions): ConnectWebviewsListRequest;
}
type ConnectWebviewsCreateParameters = RouteRequestBody<'/connect_webviews/create'>;
/**
 * @deprecated Use ConnectWebviewsCreateParameters instead.
 */
type ConnectWebviewsCreateBody = ConnectWebviewsCreateParameters;
/**
 * @deprecated Use ConnectWebviewsCreateRequest instead.
 */
type ConnectWebviewsCreateResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/create'>>>;
type ConnectWebviewsCreateRequest = SeamHttpRequest<ConnectWebviewsCreateResponse, 'connect_webview'>;
interface ConnectWebviewsCreateOptions {
}
type ConnectWebviewsDeleteParameters = RouteRequestBody<'/connect_webviews/delete'>;
/**
 * @deprecated Use ConnectWebviewsDeleteParameters instead.
 */
type ConnectWebviewsDeleteParams = ConnectWebviewsDeleteParameters;
/**
 * @deprecated Use ConnectWebviewsDeleteRequest instead.
 */
type ConnectWebviewsDeleteResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/delete'>>>;
type ConnectWebviewsDeleteRequest = SeamHttpRequest<void, undefined>;
interface ConnectWebviewsDeleteOptions {
}
type ConnectWebviewsGetParameters = RouteRequestBody<'/connect_webviews/get'>;
/**
 * @deprecated Use ConnectWebviewsGetParameters instead.
 */
type ConnectWebviewsGetParams = ConnectWebviewsGetParameters;
/**
 * @deprecated Use ConnectWebviewsGetRequest instead.
 */
type ConnectWebviewsGetResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/get'>>>;
type ConnectWebviewsGetRequest = SeamHttpRequest<ConnectWebviewsGetResponse, 'connect_webview'>;
interface ConnectWebviewsGetOptions {
}
type ConnectWebviewsListParameters = RouteRequestBody<'/connect_webviews/list'>;
/**
 * @deprecated Use ConnectWebviewsListParameters instead.
 */
type ConnectWebviewsListParams = ConnectWebviewsListParameters;
/**
 * @deprecated Use ConnectWebviewsListRequest instead.
 */
type ConnectWebviewsListResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/list'>>>;
type ConnectWebviewsListRequest = SeamHttpRequest<ConnectWebviewsListResponse, 'connect_webviews'>;
interface ConnectWebviewsListOptions {
}

declare class SeamHttpConnectedAccountsSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpConnectedAccountsSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpConnectedAccountsSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpConnectedAccountsSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpConnectedAccountsSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpConnectedAccountsSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpConnectedAccountsSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    disconnect(parameters?: ConnectedAccountsSimulateDisconnectParameters, options?: ConnectedAccountsSimulateDisconnectOptions): ConnectedAccountsSimulateDisconnectRequest;
}
type ConnectedAccountsSimulateDisconnectParameters = RouteRequestBody<'/connected_accounts/simulate/disconnect'>;
/**
 * @deprecated Use ConnectedAccountsSimulateDisconnectParameters instead.
 */
type ConnectedAccountsSimulateDisconnectBody = ConnectedAccountsSimulateDisconnectParameters;
/**
 * @deprecated Use ConnectedAccountsSimulateDisconnectRequest instead.
 */
type ConnectedAccountsSimulateDisconnectResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/simulate/disconnect'>>>;
type ConnectedAccountsSimulateDisconnectRequest = SeamHttpRequest<void, undefined>;
interface ConnectedAccountsSimulateDisconnectOptions {
}

declare class SeamHttpConnectedAccounts {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpConnectedAccounts;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpConnectedAccounts;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpConnectedAccounts;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpConnectedAccounts>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpConnectedAccounts;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpConnectedAccounts;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpConnectedAccountsSimulate;
    delete(parameters?: ConnectedAccountsDeleteParameters, options?: ConnectedAccountsDeleteOptions): ConnectedAccountsDeleteRequest;
    get(parameters?: ConnectedAccountsGetParameters, options?: ConnectedAccountsGetOptions): ConnectedAccountsGetRequest;
    list(parameters?: ConnectedAccountsListParameters, options?: ConnectedAccountsListOptions): ConnectedAccountsListRequest;
    sync(parameters?: ConnectedAccountsSyncParameters, options?: ConnectedAccountsSyncOptions): ConnectedAccountsSyncRequest;
    update(parameters?: ConnectedAccountsUpdateParameters, options?: ConnectedAccountsUpdateOptions): ConnectedAccountsUpdateRequest;
}
type ConnectedAccountsDeleteParameters = RouteRequestBody<'/connected_accounts/delete'>;
/**
 * @deprecated Use ConnectedAccountsDeleteParameters instead.
 */
type ConnectedAccountsDeleteParams = ConnectedAccountsDeleteParameters;
/**
 * @deprecated Use ConnectedAccountsDeleteRequest instead.
 */
type ConnectedAccountsDeleteResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/delete'>>>;
type ConnectedAccountsDeleteRequest = SeamHttpRequest<void, undefined>;
interface ConnectedAccountsDeleteOptions {
}
type ConnectedAccountsGetParameters = RouteRequestParams<'/connected_accounts/get'>;
/**
 * @deprecated Use ConnectedAccountsGetParameters instead.
 */
type ConnectedAccountsGetParams = ConnectedAccountsGetParameters;
/**
 * @deprecated Use ConnectedAccountsGetRequest instead.
 */
type ConnectedAccountsGetResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/get'>>>;
type ConnectedAccountsGetRequest = SeamHttpRequest<ConnectedAccountsGetResponse, 'connected_account'>;
interface ConnectedAccountsGetOptions {
}
type ConnectedAccountsListParameters = RouteRequestBody<'/connected_accounts/list'>;
/**
 * @deprecated Use ConnectedAccountsListParameters instead.
 */
type ConnectedAccountsListParams = ConnectedAccountsListParameters;
/**
 * @deprecated Use ConnectedAccountsListRequest instead.
 */
type ConnectedAccountsListResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/list'>>>;
type ConnectedAccountsListRequest = SeamHttpRequest<ConnectedAccountsListResponse, 'connected_accounts'>;
interface ConnectedAccountsListOptions {
}
type ConnectedAccountsSyncParameters = RouteRequestBody<'/connected_accounts/sync'>;
/**
 * @deprecated Use ConnectedAccountsSyncParameters instead.
 */
type ConnectedAccountsSyncBody = ConnectedAccountsSyncParameters;
/**
 * @deprecated Use ConnectedAccountsSyncRequest instead.
 */
type ConnectedAccountsSyncResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/sync'>>>;
type ConnectedAccountsSyncRequest = SeamHttpRequest<void, undefined>;
interface ConnectedAccountsSyncOptions {
}
type ConnectedAccountsUpdateParameters = RouteRequestBody<'/connected_accounts/update'>;
/**
 * @deprecated Use ConnectedAccountsUpdateParameters instead.
 */
type ConnectedAccountsUpdateBody = ConnectedAccountsUpdateParameters;
/**
 * @deprecated Use ConnectedAccountsUpdateRequest instead.
 */
type ConnectedAccountsUpdateResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/update'>>>;
type ConnectedAccountsUpdateRequest = SeamHttpRequest<void, undefined>;
interface ConnectedAccountsUpdateOptions {
}

declare class SeamHttpCustomersReservations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpCustomersReservations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpCustomersReservations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpCustomersReservations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpCustomersReservations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpCustomersReservations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpCustomersReservations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    createDeepLink(parameters?: CustomersReservationsCreateDeepLinkParameters, options?: CustomersReservationsCreateDeepLinkOptions): CustomersReservationsCreateDeepLinkRequest;
}
type CustomersReservationsCreateDeepLinkParameters = RouteRequestBody<'/customers/reservations/create_deep_link'>;
/**
 * @deprecated Use CustomersReservationsCreateDeepLinkParameters instead.
 */
type CustomersReservationsCreateDeepLinkBody = CustomersReservationsCreateDeepLinkParameters;
/**
 * @deprecated Use CustomersReservationsCreateDeepLinkRequest instead.
 */
type CustomersReservationsCreateDeepLinkResponse = SetNonNullable<Required<RouteResponse<'/customers/reservations/create_deep_link'>>>;
type CustomersReservationsCreateDeepLinkRequest = SeamHttpRequest<CustomersReservationsCreateDeepLinkResponse, 'deep_link'>;
interface CustomersReservationsCreateDeepLinkOptions {
}

declare class SeamHttpCustomers {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpCustomers;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpCustomers;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpCustomers;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpCustomers>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpCustomers;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpCustomers;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get reservations(): SeamHttpCustomersReservations;
    createPortal(parameters?: CustomersCreatePortalParameters, options?: CustomersCreatePortalOptions): CustomersCreatePortalRequest;
    deleteData(parameters?: CustomersDeleteDataParameters, options?: CustomersDeleteDataOptions): CustomersDeleteDataRequest;
    pushData(parameters?: CustomersPushDataParameters, options?: CustomersPushDataOptions): CustomersPushDataRequest;
}
type CustomersCreatePortalParameters = RouteRequestBody<'/customers/create_portal'>;
/**
 * @deprecated Use CustomersCreatePortalParameters instead.
 */
type CustomersCreatePortalBody = CustomersCreatePortalParameters;
/**
 * @deprecated Use CustomersCreatePortalRequest instead.
 */
type CustomersCreatePortalResponse = SetNonNullable<Required<RouteResponse<'/customers/create_portal'>>>;
type CustomersCreatePortalRequest = SeamHttpRequest<CustomersCreatePortalResponse, 'customer_portal'>;
interface CustomersCreatePortalOptions {
}
type CustomersDeleteDataParameters = RouteRequestBody<'/customers/delete_data'>;
/**
 * @deprecated Use CustomersDeleteDataParameters instead.
 */
type CustomersDeleteDataParams = CustomersDeleteDataParameters;
/**
 * @deprecated Use CustomersDeleteDataRequest instead.
 */
type CustomersDeleteDataResponse = SetNonNullable<Required<RouteResponse<'/customers/delete_data'>>>;
type CustomersDeleteDataRequest = SeamHttpRequest<void, undefined>;
interface CustomersDeleteDataOptions {
}
type CustomersPushDataParameters = RouteRequestBody<'/customers/push_data'>;
/**
 * @deprecated Use CustomersPushDataParameters instead.
 */
type CustomersPushDataBody = CustomersPushDataParameters;
/**
 * @deprecated Use CustomersPushDataRequest instead.
 */
type CustomersPushDataResponse = SetNonNullable<Required<RouteResponse<'/customers/push_data'>>>;
type CustomersPushDataRequest = SeamHttpRequest<void, undefined>;
interface CustomersPushDataOptions {
}

declare class SeamHttpDevicesSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpDevicesSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpDevicesSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpDevicesSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpDevicesSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpDevicesSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpDevicesSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    connect(parameters?: DevicesSimulateConnectParameters, options?: DevicesSimulateConnectOptions): DevicesSimulateConnectRequest;
    connectToHub(parameters?: DevicesSimulateConnectToHubParameters, options?: DevicesSimulateConnectToHubOptions): DevicesSimulateConnectToHubRequest;
    disconnect(parameters?: DevicesSimulateDisconnectParameters, options?: DevicesSimulateDisconnectOptions): DevicesSimulateDisconnectRequest;
    disconnectFromHub(parameters?: DevicesSimulateDisconnectFromHubParameters, options?: DevicesSimulateDisconnectFromHubOptions): DevicesSimulateDisconnectFromHubRequest;
    paidSubscription(parameters?: DevicesSimulatePaidSubscriptionParameters, options?: DevicesSimulatePaidSubscriptionOptions): DevicesSimulatePaidSubscriptionRequest;
    remove(parameters?: DevicesSimulateRemoveParameters, options?: DevicesSimulateRemoveOptions): DevicesSimulateRemoveRequest;
}
type DevicesSimulateConnectParameters = RouteRequestBody<'/devices/simulate/connect'>;
/**
 * @deprecated Use DevicesSimulateConnectParameters instead.
 */
type DevicesSimulateConnectBody = DevicesSimulateConnectParameters;
/**
 * @deprecated Use DevicesSimulateConnectRequest instead.
 */
type DevicesSimulateConnectResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/connect'>>>;
type DevicesSimulateConnectRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulateConnectOptions {
}
type DevicesSimulateConnectToHubParameters = RouteRequestBody<'/devices/simulate/connect_to_hub'>;
/**
 * @deprecated Use DevicesSimulateConnectToHubParameters instead.
 */
type DevicesSimulateConnectToHubBody = DevicesSimulateConnectToHubParameters;
/**
 * @deprecated Use DevicesSimulateConnectToHubRequest instead.
 */
type DevicesSimulateConnectToHubResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/connect_to_hub'>>>;
type DevicesSimulateConnectToHubRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulateConnectToHubOptions {
}
type DevicesSimulateDisconnectParameters = RouteRequestBody<'/devices/simulate/disconnect'>;
/**
 * @deprecated Use DevicesSimulateDisconnectParameters instead.
 */
type DevicesSimulateDisconnectBody = DevicesSimulateDisconnectParameters;
/**
 * @deprecated Use DevicesSimulateDisconnectRequest instead.
 */
type DevicesSimulateDisconnectResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/disconnect'>>>;
type DevicesSimulateDisconnectRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulateDisconnectOptions {
}
type DevicesSimulateDisconnectFromHubParameters = RouteRequestBody<'/devices/simulate/disconnect_from_hub'>;
/**
 * @deprecated Use DevicesSimulateDisconnectFromHubParameters instead.
 */
type DevicesSimulateDisconnectFromHubBody = DevicesSimulateDisconnectFromHubParameters;
/**
 * @deprecated Use DevicesSimulateDisconnectFromHubRequest instead.
 */
type DevicesSimulateDisconnectFromHubResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/disconnect_from_hub'>>>;
type DevicesSimulateDisconnectFromHubRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulateDisconnectFromHubOptions {
}
type DevicesSimulatePaidSubscriptionParameters = RouteRequestBody<'/devices/simulate/paid_subscription'>;
/**
 * @deprecated Use DevicesSimulatePaidSubscriptionParameters instead.
 */
type DevicesSimulatePaidSubscriptionBody = DevicesSimulatePaidSubscriptionParameters;
/**
 * @deprecated Use DevicesSimulatePaidSubscriptionRequest instead.
 */
type DevicesSimulatePaidSubscriptionResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/paid_subscription'>>>;
type DevicesSimulatePaidSubscriptionRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulatePaidSubscriptionOptions {
}
type DevicesSimulateRemoveParameters = RouteRequestBody<'/devices/simulate/remove'>;
/**
 * @deprecated Use DevicesSimulateRemoveParameters instead.
 */
type DevicesSimulateRemoveBody = DevicesSimulateRemoveParameters;
/**
 * @deprecated Use DevicesSimulateRemoveRequest instead.
 */
type DevicesSimulateRemoveResponse = SetNonNullable<Required<RouteResponse<'/devices/simulate/remove'>>>;
type DevicesSimulateRemoveRequest = SeamHttpRequest<void, undefined>;
interface DevicesSimulateRemoveOptions {
}

declare class SeamHttpDevicesUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpDevicesUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpDevicesUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpDevicesUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpDevicesUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpDevicesUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpDevicesUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: DevicesUnmanagedGetParameters, options?: DevicesUnmanagedGetOptions): DevicesUnmanagedGetRequest;
    list(parameters?: DevicesUnmanagedListParameters, options?: DevicesUnmanagedListOptions): DevicesUnmanagedListRequest;
    update(parameters?: DevicesUnmanagedUpdateParameters, options?: DevicesUnmanagedUpdateOptions): DevicesUnmanagedUpdateRequest;
}
type DevicesUnmanagedGetParameters = RouteRequestBody<'/devices/unmanaged/get'>;
/**
 * @deprecated Use DevicesUnmanagedGetParameters instead.
 */
type DevicesUnmanagedGetParams = DevicesUnmanagedGetParameters;
/**
 * @deprecated Use DevicesUnmanagedGetRequest instead.
 */
type DevicesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/get'>>>;
type DevicesUnmanagedGetRequest = SeamHttpRequest<DevicesUnmanagedGetResponse, 'device'>;
interface DevicesUnmanagedGetOptions {
}
type DevicesUnmanagedListParameters = RouteRequestBody<'/devices/unmanaged/list'>;
/**
 * @deprecated Use DevicesUnmanagedListParameters instead.
 */
type DevicesUnmanagedListParams = DevicesUnmanagedListParameters;
/**
 * @deprecated Use DevicesUnmanagedListRequest instead.
 */
type DevicesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/list'>>>;
type DevicesUnmanagedListRequest = SeamHttpRequest<DevicesUnmanagedListResponse, 'devices'>;
interface DevicesUnmanagedListOptions {
}
type DevicesUnmanagedUpdateParameters = RouteRequestBody<'/devices/unmanaged/update'>;
/**
 * @deprecated Use DevicesUnmanagedUpdateParameters instead.
 */
type DevicesUnmanagedUpdateBody = DevicesUnmanagedUpdateParameters;
/**
 * @deprecated Use DevicesUnmanagedUpdateRequest instead.
 */
type DevicesUnmanagedUpdateResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/update'>>>;
type DevicesUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>;
interface DevicesUnmanagedUpdateOptions {
}

declare class SeamHttpDevices {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpDevices;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpDevices;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpDevices;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpDevices>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpDevices;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpDevices;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpDevicesSimulate;
    get unmanaged(): SeamHttpDevicesUnmanaged;
    delete(parameters?: DevicesDeleteParameters, options?: DevicesDeleteOptions): DevicesDeleteRequest;
    get(parameters?: DevicesGetParameters, options?: DevicesGetOptions): DevicesGetRequest;
    list(parameters?: DevicesListParameters, options?: DevicesListOptions): DevicesListRequest;
    listDeviceProviders(parameters?: DevicesListDeviceProvidersParameters, options?: DevicesListDeviceProvidersOptions): DevicesListDeviceProvidersRequest;
    reportProviderMetadata(parameters?: DevicesReportProviderMetadataParameters, options?: DevicesReportProviderMetadataOptions): DevicesReportProviderMetadataRequest;
    update(parameters?: DevicesUpdateParameters, options?: DevicesUpdateOptions): DevicesUpdateRequest;
}
type DevicesDeleteParameters = RouteRequestBody<'/devices/delete'>;
/**
 * @deprecated Use DevicesDeleteParameters instead.
 */
type DevicesDeleteParams = DevicesDeleteParameters;
/**
 * @deprecated Use DevicesDeleteRequest instead.
 */
type DevicesDeleteResponse = SetNonNullable<Required<RouteResponse<'/devices/delete'>>>;
type DevicesDeleteRequest = SeamHttpRequest<void, undefined>;
interface DevicesDeleteOptions {
}
type DevicesGetParameters = RouteRequestBody<'/devices/get'>;
/**
 * @deprecated Use DevicesGetParameters instead.
 */
type DevicesGetParams = DevicesGetParameters;
/**
 * @deprecated Use DevicesGetRequest instead.
 */
type DevicesGetResponse = SetNonNullable<Required<RouteResponse<'/devices/get'>>>;
type DevicesGetRequest = SeamHttpRequest<DevicesGetResponse, 'device'>;
interface DevicesGetOptions {
}
type DevicesListParameters = RouteRequestBody<'/devices/list'>;
/**
 * @deprecated Use DevicesListParameters instead.
 */
type DevicesListParams = DevicesListParameters;
/**
 * @deprecated Use DevicesListRequest instead.
 */
type DevicesListResponse = SetNonNullable<Required<RouteResponse<'/devices/list'>>>;
type DevicesListRequest = SeamHttpRequest<DevicesListResponse, 'devices'>;
interface DevicesListOptions {
}
type DevicesListDeviceProvidersParameters = RouteRequestBody<'/devices/list_device_providers'>;
/**
 * @deprecated Use DevicesListDeviceProvidersParameters instead.
 */
type DevicesListDeviceProvidersParams = DevicesListDeviceProvidersParameters;
/**
 * @deprecated Use DevicesListDeviceProvidersRequest instead.
 */
type DevicesListDeviceProvidersResponse = SetNonNullable<Required<RouteResponse<'/devices/list_device_providers'>>>;
type DevicesListDeviceProvidersRequest = SeamHttpRequest<DevicesListDeviceProvidersResponse, 'device_providers'>;
interface DevicesListDeviceProvidersOptions {
}
type DevicesReportProviderMetadataParameters = RouteRequestBody<'/devices/report_provider_metadata'>;
/**
 * @deprecated Use DevicesReportProviderMetadataParameters instead.
 */
type DevicesReportProviderMetadataBody = DevicesReportProviderMetadataParameters;
/**
 * @deprecated Use DevicesReportProviderMetadataRequest instead.
 */
type DevicesReportProviderMetadataResponse = SetNonNullable<Required<RouteResponse<'/devices/report_provider_metadata'>>>;
type DevicesReportProviderMetadataRequest = SeamHttpRequest<void, undefined>;
interface DevicesReportProviderMetadataOptions {
}
type DevicesUpdateParameters = RouteRequestBody<'/devices/update'>;
/**
 * @deprecated Use DevicesUpdateParameters instead.
 */
type DevicesUpdateBody = DevicesUpdateParameters;
/**
 * @deprecated Use DevicesUpdateRequest instead.
 */
type DevicesUpdateResponse = SetNonNullable<Required<RouteResponse<'/devices/update'>>>;
type DevicesUpdateRequest = SeamHttpRequest<void, undefined>;
interface DevicesUpdateOptions {
}

declare class SeamHttpEvents {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpEvents;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpEvents;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpEvents;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpEvents>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpEvents;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpEvents;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: EventsGetParameters, options?: EventsGetOptions): EventsGetRequest;
    list(parameters?: EventsListParameters, options?: EventsListOptions): EventsListRequest;
}
type EventsGetParameters = RouteRequestBody<'/events/get'>;
/**
 * @deprecated Use EventsGetParameters instead.
 */
type EventsGetParams = EventsGetParameters;
/**
 * @deprecated Use EventsGetRequest instead.
 */
type EventsGetResponse = SetNonNullable<Required<RouteResponse<'/events/get'>>>;
type EventsGetRequest = SeamHttpRequest<EventsGetResponse, 'event'>;
interface EventsGetOptions {
}
type EventsListParameters = RouteRequestBody<'/events/list'>;
/**
 * @deprecated Use EventsListParameters instead.
 */
type EventsListParams = EventsListParameters;
/**
 * @deprecated Use EventsListRequest instead.
 */
type EventsListResponse = SetNonNullable<Required<RouteResponse<'/events/list'>>>;
type EventsListRequest = SeamHttpRequest<EventsListResponse, 'events'>;
interface EventsListOptions {
}

declare class SeamHttpInstantKeys {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpInstantKeys;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpInstantKeys;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpInstantKeys;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpInstantKeys>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpInstantKeys;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpInstantKeys;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    delete(parameters?: InstantKeysDeleteParameters, options?: InstantKeysDeleteOptions): InstantKeysDeleteRequest;
    get(parameters?: InstantKeysGetParameters, options?: InstantKeysGetOptions): InstantKeysGetRequest;
    list(parameters?: InstantKeysListParameters, options?: InstantKeysListOptions): InstantKeysListRequest;
}
type InstantKeysDeleteParameters = RouteRequestBody<'/instant_keys/delete'>;
/**
 * @deprecated Use InstantKeysDeleteParameters instead.
 */
type InstantKeysDeleteParams = InstantKeysDeleteParameters;
/**
 * @deprecated Use InstantKeysDeleteRequest instead.
 */
type InstantKeysDeleteResponse = SetNonNullable<Required<RouteResponse<'/instant_keys/delete'>>>;
type InstantKeysDeleteRequest = SeamHttpRequest<void, undefined>;
interface InstantKeysDeleteOptions {
}
type InstantKeysGetParameters = RouteRequestBody<'/instant_keys/get'>;
/**
 * @deprecated Use InstantKeysGetParameters instead.
 */
type InstantKeysGetParams = InstantKeysGetParameters;
/**
 * @deprecated Use InstantKeysGetRequest instead.
 */
type InstantKeysGetResponse = SetNonNullable<Required<RouteResponse<'/instant_keys/get'>>>;
type InstantKeysGetRequest = SeamHttpRequest<InstantKeysGetResponse, 'instant_key'>;
interface InstantKeysGetOptions {
}
type InstantKeysListParameters = RouteRequestBody<'/instant_keys/list'>;
/**
 * @deprecated Use InstantKeysListParameters instead.
 */
type InstantKeysListParams = InstantKeysListParameters;
/**
 * @deprecated Use InstantKeysListRequest instead.
 */
type InstantKeysListResponse = SetNonNullable<Required<RouteResponse<'/instant_keys/list'>>>;
type InstantKeysListRequest = SeamHttpRequest<InstantKeysListResponse, 'instant_keys'>;
interface InstantKeysListOptions {
}

declare class SeamHttpLocksSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpLocksSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpLocksSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpLocksSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpLocksSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpLocksSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpLocksSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    keypadCodeEntry(parameters?: LocksSimulateKeypadCodeEntryParameters, options?: LocksSimulateKeypadCodeEntryOptions): LocksSimulateKeypadCodeEntryRequest;
    manualLockViaKeypad(parameters?: LocksSimulateManualLockViaKeypadParameters, options?: LocksSimulateManualLockViaKeypadOptions): LocksSimulateManualLockViaKeypadRequest;
}
type LocksSimulateKeypadCodeEntryParameters = RouteRequestBody<'/locks/simulate/keypad_code_entry'>;
/**
 * @deprecated Use LocksSimulateKeypadCodeEntryParameters instead.
 */
type LocksSimulateKeypadCodeEntryBody = LocksSimulateKeypadCodeEntryParameters;
/**
 * @deprecated Use LocksSimulateKeypadCodeEntryRequest instead.
 */
type LocksSimulateKeypadCodeEntryResponse = SetNonNullable<Required<RouteResponse<'/locks/simulate/keypad_code_entry'>>>;
type LocksSimulateKeypadCodeEntryRequest = SeamHttpRequest<LocksSimulateKeypadCodeEntryResponse, 'action_attempt'>;
type LocksSimulateKeypadCodeEntryOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type LocksSimulateManualLockViaKeypadParameters = RouteRequestBody<'/locks/simulate/manual_lock_via_keypad'>;
/**
 * @deprecated Use LocksSimulateManualLockViaKeypadParameters instead.
 */
type LocksSimulateManualLockViaKeypadBody = LocksSimulateManualLockViaKeypadParameters;
/**
 * @deprecated Use LocksSimulateManualLockViaKeypadRequest instead.
 */
type LocksSimulateManualLockViaKeypadResponse = SetNonNullable<Required<RouteResponse<'/locks/simulate/manual_lock_via_keypad'>>>;
type LocksSimulateManualLockViaKeypadRequest = SeamHttpRequest<LocksSimulateManualLockViaKeypadResponse, 'action_attempt'>;
type LocksSimulateManualLockViaKeypadOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpLocks {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpLocks;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpLocks;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpLocks;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpLocks>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpLocks;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpLocks;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpLocksSimulate;
    configureAutoLock(parameters?: LocksConfigureAutoLockParameters, options?: LocksConfigureAutoLockOptions): LocksConfigureAutoLockRequest;
    get(parameters?: LocksGetParameters, options?: LocksGetOptions): LocksGetRequest;
    list(parameters?: LocksListParameters, options?: LocksListOptions): LocksListRequest;
    lockDoor(parameters?: LocksLockDoorParameters, options?: LocksLockDoorOptions): LocksLockDoorRequest;
    unlockDoor(parameters?: LocksUnlockDoorParameters, options?: LocksUnlockDoorOptions): LocksUnlockDoorRequest;
}
type LocksConfigureAutoLockParameters = RouteRequestBody<'/locks/configure_auto_lock'>;
/**
 * @deprecated Use LocksConfigureAutoLockParameters instead.
 */
type LocksConfigureAutoLockBody = LocksConfigureAutoLockParameters;
/**
 * @deprecated Use LocksConfigureAutoLockRequest instead.
 */
type LocksConfigureAutoLockResponse = SetNonNullable<Required<RouteResponse<'/locks/configure_auto_lock'>>>;
type LocksConfigureAutoLockRequest = SeamHttpRequest<LocksConfigureAutoLockResponse, 'action_attempt'>;
type LocksConfigureAutoLockOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type LocksGetParameters = RouteRequestBody<'/locks/get'>;
/**
 * @deprecated Use LocksGetParameters instead.
 */
type LocksGetParams = LocksGetParameters;
/**
 * @deprecated Use LocksGetRequest instead.
 */
type LocksGetResponse = SetNonNullable<Required<RouteResponse<'/locks/get'>>>;
type LocksGetRequest = SeamHttpRequest<LocksGetResponse, 'device'>;
interface LocksGetOptions {
}
type LocksListParameters = RouteRequestBody<'/locks/list'>;
/**
 * @deprecated Use LocksListParameters instead.
 */
type LocksListParams = LocksListParameters;
/**
 * @deprecated Use LocksListRequest instead.
 */
type LocksListResponse = SetNonNullable<Required<RouteResponse<'/locks/list'>>>;
type LocksListRequest = SeamHttpRequest<LocksListResponse, 'devices'>;
interface LocksListOptions {
}
type LocksLockDoorParameters = RouteRequestBody<'/locks/lock_door'>;
/**
 * @deprecated Use LocksLockDoorParameters instead.
 */
type LocksLockDoorBody = LocksLockDoorParameters;
/**
 * @deprecated Use LocksLockDoorRequest instead.
 */
type LocksLockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/lock_door'>>>;
type LocksLockDoorRequest = SeamHttpRequest<LocksLockDoorResponse, 'action_attempt'>;
type LocksLockDoorOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type LocksUnlockDoorParameters = RouteRequestBody<'/locks/unlock_door'>;
/**
 * @deprecated Use LocksUnlockDoorParameters instead.
 */
type LocksUnlockDoorBody = LocksUnlockDoorParameters;
/**
 * @deprecated Use LocksUnlockDoorRequest instead.
 */
type LocksUnlockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/unlock_door'>>>;
type LocksUnlockDoorRequest = SeamHttpRequest<LocksUnlockDoorResponse, 'action_attempt'>;
type LocksUnlockDoorOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpNoiseSensorsNoiseThresholds {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpNoiseSensorsNoiseThresholds;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpNoiseSensorsNoiseThresholds;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpNoiseSensorsNoiseThresholds;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpNoiseSensorsNoiseThresholds>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpNoiseSensorsNoiseThresholds;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpNoiseSensorsNoiseThresholds;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: NoiseSensorsNoiseThresholdsCreateParameters, options?: NoiseSensorsNoiseThresholdsCreateOptions): NoiseSensorsNoiseThresholdsCreateRequest;
    delete(parameters?: NoiseSensorsNoiseThresholdsDeleteParameters, options?: NoiseSensorsNoiseThresholdsDeleteOptions): NoiseSensorsNoiseThresholdsDeleteRequest;
    get(parameters?: NoiseSensorsNoiseThresholdsGetParameters, options?: NoiseSensorsNoiseThresholdsGetOptions): NoiseSensorsNoiseThresholdsGetRequest;
    list(parameters?: NoiseSensorsNoiseThresholdsListParameters, options?: NoiseSensorsNoiseThresholdsListOptions): NoiseSensorsNoiseThresholdsListRequest;
    update(parameters?: NoiseSensorsNoiseThresholdsUpdateParameters, options?: NoiseSensorsNoiseThresholdsUpdateOptions): NoiseSensorsNoiseThresholdsUpdateRequest;
}
type NoiseSensorsNoiseThresholdsCreateParameters = RouteRequestBody<'/noise_sensors/noise_thresholds/create'>;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsCreateParameters instead.
 */
type NoiseSensorsNoiseThresholdsCreateBody = NoiseSensorsNoiseThresholdsCreateParameters;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsCreateRequest instead.
 */
type NoiseSensorsNoiseThresholdsCreateResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/create'>>>;
type NoiseSensorsNoiseThresholdsCreateRequest = SeamHttpRequest<NoiseSensorsNoiseThresholdsCreateResponse, 'noise_threshold'>;
interface NoiseSensorsNoiseThresholdsCreateOptions {
}
type NoiseSensorsNoiseThresholdsDeleteParameters = RouteRequestBody<'/noise_sensors/noise_thresholds/delete'>;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsDeleteParameters instead.
 */
type NoiseSensorsNoiseThresholdsDeleteParams = NoiseSensorsNoiseThresholdsDeleteParameters;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsDeleteRequest instead.
 */
type NoiseSensorsNoiseThresholdsDeleteResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/delete'>>>;
type NoiseSensorsNoiseThresholdsDeleteRequest = SeamHttpRequest<void, undefined>;
interface NoiseSensorsNoiseThresholdsDeleteOptions {
}
type NoiseSensorsNoiseThresholdsGetParameters = RouteRequestBody<'/noise_sensors/noise_thresholds/get'>;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsGetParameters instead.
 */
type NoiseSensorsNoiseThresholdsGetParams = NoiseSensorsNoiseThresholdsGetParameters;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsGetRequest instead.
 */
type NoiseSensorsNoiseThresholdsGetResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/get'>>>;
type NoiseSensorsNoiseThresholdsGetRequest = SeamHttpRequest<NoiseSensorsNoiseThresholdsGetResponse, 'noise_threshold'>;
interface NoiseSensorsNoiseThresholdsGetOptions {
}
type NoiseSensorsNoiseThresholdsListParameters = RouteRequestBody<'/noise_sensors/noise_thresholds/list'>;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsListParameters instead.
 */
type NoiseSensorsNoiseThresholdsListParams = NoiseSensorsNoiseThresholdsListParameters;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsListRequest instead.
 */
type NoiseSensorsNoiseThresholdsListResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/list'>>>;
type NoiseSensorsNoiseThresholdsListRequest = SeamHttpRequest<NoiseSensorsNoiseThresholdsListResponse, 'noise_thresholds'>;
interface NoiseSensorsNoiseThresholdsListOptions {
}
type NoiseSensorsNoiseThresholdsUpdateParameters = RouteRequestBody<'/noise_sensors/noise_thresholds/update'>;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsUpdateParameters instead.
 */
type NoiseSensorsNoiseThresholdsUpdateBody = NoiseSensorsNoiseThresholdsUpdateParameters;
/**
 * @deprecated Use NoiseSensorsNoiseThresholdsUpdateRequest instead.
 */
type NoiseSensorsNoiseThresholdsUpdateResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/update'>>>;
type NoiseSensorsNoiseThresholdsUpdateRequest = SeamHttpRequest<void, undefined>;
interface NoiseSensorsNoiseThresholdsUpdateOptions {
}

declare class SeamHttpNoiseSensorsSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpNoiseSensorsSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpNoiseSensorsSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpNoiseSensorsSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpNoiseSensorsSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpNoiseSensorsSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpNoiseSensorsSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    triggerNoiseThreshold(parameters?: NoiseSensorsSimulateTriggerNoiseThresholdParameters, options?: NoiseSensorsSimulateTriggerNoiseThresholdOptions): NoiseSensorsSimulateTriggerNoiseThresholdRequest;
}
type NoiseSensorsSimulateTriggerNoiseThresholdParameters = RouteRequestBody<'/noise_sensors/simulate/trigger_noise_threshold'>;
/**
 * @deprecated Use NoiseSensorsSimulateTriggerNoiseThresholdParameters instead.
 */
type NoiseSensorsSimulateTriggerNoiseThresholdBody = NoiseSensorsSimulateTriggerNoiseThresholdParameters;
/**
 * @deprecated Use NoiseSensorsSimulateTriggerNoiseThresholdRequest instead.
 */
type NoiseSensorsSimulateTriggerNoiseThresholdResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/simulate/trigger_noise_threshold'>>>;
type NoiseSensorsSimulateTriggerNoiseThresholdRequest = SeamHttpRequest<void, undefined>;
interface NoiseSensorsSimulateTriggerNoiseThresholdOptions {
}

declare class SeamHttpNoiseSensors {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpNoiseSensors;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpNoiseSensors;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpNoiseSensors;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpNoiseSensors>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpNoiseSensors;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpNoiseSensors;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get noiseThresholds(): SeamHttpNoiseSensorsNoiseThresholds;
    get simulate(): SeamHttpNoiseSensorsSimulate;
    list(parameters?: NoiseSensorsListParameters, options?: NoiseSensorsListOptions): NoiseSensorsListRequest;
}
type NoiseSensorsListParameters = RouteRequestBody<'/noise_sensors/list'>;
/**
 * @deprecated Use NoiseSensorsListParameters instead.
 */
type NoiseSensorsListParams = NoiseSensorsListParameters;
/**
 * @deprecated Use NoiseSensorsListRequest instead.
 */
type NoiseSensorsListResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/list'>>>;
type NoiseSensorsListRequest = SeamHttpRequest<NoiseSensorsListResponse, 'devices'>;
interface NoiseSensorsListOptions {
}

declare class SeamHttpPhonesSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpPhonesSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpPhonesSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpPhonesSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpPhonesSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpPhonesSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpPhonesSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    createSandboxPhone(parameters?: PhonesSimulateCreateSandboxPhoneParameters, options?: PhonesSimulateCreateSandboxPhoneOptions): PhonesSimulateCreateSandboxPhoneRequest;
}
type PhonesSimulateCreateSandboxPhoneParameters = RouteRequestBody<'/phones/simulate/create_sandbox_phone'>;
/**
 * @deprecated Use PhonesSimulateCreateSandboxPhoneParameters instead.
 */
type PhonesSimulateCreateSandboxPhoneBody = PhonesSimulateCreateSandboxPhoneParameters;
/**
 * @deprecated Use PhonesSimulateCreateSandboxPhoneRequest instead.
 */
type PhonesSimulateCreateSandboxPhoneResponse = SetNonNullable<Required<RouteResponse<'/phones/simulate/create_sandbox_phone'>>>;
type PhonesSimulateCreateSandboxPhoneRequest = SeamHttpRequest<PhonesSimulateCreateSandboxPhoneResponse, 'phone'>;
interface PhonesSimulateCreateSandboxPhoneOptions {
}

declare class SeamHttpPhones {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpPhones;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpPhones;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpPhones;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpPhones>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpPhones;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpPhones;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get simulate(): SeamHttpPhonesSimulate;
    deactivate(parameters?: PhonesDeactivateParameters, options?: PhonesDeactivateOptions): PhonesDeactivateRequest;
    get(parameters?: PhonesGetParameters, options?: PhonesGetOptions): PhonesGetRequest;
    list(parameters?: PhonesListParameters, options?: PhonesListOptions): PhonesListRequest;
}
type PhonesDeactivateParameters = RouteRequestBody<'/phones/deactivate'>;
/**
 * @deprecated Use PhonesDeactivateParameters instead.
 */
type PhonesDeactivateParams = PhonesDeactivateParameters;
/**
 * @deprecated Use PhonesDeactivateRequest instead.
 */
type PhonesDeactivateResponse = SetNonNullable<Required<RouteResponse<'/phones/deactivate'>>>;
type PhonesDeactivateRequest = SeamHttpRequest<void, undefined>;
interface PhonesDeactivateOptions {
}
type PhonesGetParameters = RouteRequestBody<'/phones/get'>;
/**
 * @deprecated Use PhonesGetParameters instead.
 */
type PhonesGetParams = PhonesGetParameters;
/**
 * @deprecated Use PhonesGetRequest instead.
 */
type PhonesGetResponse = SetNonNullable<Required<RouteResponse<'/phones/get'>>>;
type PhonesGetRequest = SeamHttpRequest<PhonesGetResponse, 'phone'>;
interface PhonesGetOptions {
}
type PhonesListParameters = RouteRequestBody<'/phones/list'>;
/**
 * @deprecated Use PhonesListParameters instead.
 */
type PhonesListParams = PhonesListParameters;
/**
 * @deprecated Use PhonesListRequest instead.
 */
type PhonesListResponse = SetNonNullable<Required<RouteResponse<'/phones/list'>>>;
type PhonesListRequest = SeamHttpRequest<PhonesListResponse, 'phones'>;
interface PhonesListOptions {
}

declare class SeamHttpSeamConsoleV1Timelines {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamConsoleV1Timelines;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamConsoleV1Timelines;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamConsoleV1Timelines;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamConsoleV1Timelines>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamConsoleV1Timelines;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamConsoleV1Timelines;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamConsoleV1TimelinesGetParameters, options?: SeamConsoleV1TimelinesGetOptions): SeamConsoleV1TimelinesGetRequest;
}
type SeamConsoleV1TimelinesGetParameters = RouteRequestBody<'/seam/console/v1/timelines/get'>;
/**
 * @deprecated Use SeamConsoleV1TimelinesGetParameters instead.
 */
type SeamConsoleV1TimelinesGetParams = SeamConsoleV1TimelinesGetParameters;
/**
 * @deprecated Use SeamConsoleV1TimelinesGetRequest instead.
 */
type SeamConsoleV1TimelinesGetResponse = SetNonNullable<Required<RouteResponse<'/seam/console/v1/timelines/get'>>>;
type SeamConsoleV1TimelinesGetRequest = SeamHttpRequest<SeamConsoleV1TimelinesGetResponse, 'timeline'>;
interface SeamConsoleV1TimelinesGetOptions {
}

declare class SeamHttpSeamConsoleV1 {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamConsoleV1;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamConsoleV1;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamConsoleV1;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamConsoleV1>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamConsoleV1;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamConsoleV1;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get timelines(): SeamHttpSeamConsoleV1Timelines;
    getResourceLocator(parameters?: SeamConsoleV1GetResourceLocatorParameters, options?: SeamConsoleV1GetResourceLocatorOptions): SeamConsoleV1GetResourceLocatorRequest;
}
type SeamConsoleV1GetResourceLocatorParameters = RouteRequestParams<'/seam/console/v1/get_resource_locator'>;
/**
 * @deprecated Use SeamConsoleV1GetResourceLocatorParameters instead.
 */
type SeamConsoleV1GetResourceLocatorParams = SeamConsoleV1GetResourceLocatorParameters;
/**
 * @deprecated Use SeamConsoleV1GetResourceLocatorRequest instead.
 */
type SeamConsoleV1GetResourceLocatorResponse = SetNonNullable<Required<RouteResponse<'/seam/console/v1/get_resource_locator'>>>;
type SeamConsoleV1GetResourceLocatorRequest = SeamHttpRequest<SeamConsoleV1GetResourceLocatorResponse, 'resource_locator'>;
interface SeamConsoleV1GetResourceLocatorOptions {
}

declare class SeamHttpSeamConsole {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamConsole;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamConsole;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamConsole;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamConsole>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamConsole;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamConsole;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get v1(): SeamHttpSeamConsoleV1;
}

declare class SeamHttpSeamCustomerV1AccessGrants {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1AccessGrants;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1AccessGrants;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1AccessGrants;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1AccessGrants>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AccessGrants;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AccessGrants;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: SeamCustomerV1AccessGrantsListParameters, options?: SeamCustomerV1AccessGrantsListOptions): SeamCustomerV1AccessGrantsListRequest;
    update(parameters?: SeamCustomerV1AccessGrantsUpdateParameters, options?: SeamCustomerV1AccessGrantsUpdateOptions): SeamCustomerV1AccessGrantsUpdateRequest;
}
type SeamCustomerV1AccessGrantsListParameters = RouteRequestBody<'/seam/customer/v1/access_grants/list'>;
/**
 * @deprecated Use SeamCustomerV1AccessGrantsListParameters instead.
 */
type SeamCustomerV1AccessGrantsListParams = SeamCustomerV1AccessGrantsListParameters;
/**
 * @deprecated Use SeamCustomerV1AccessGrantsListRequest instead.
 */
type SeamCustomerV1AccessGrantsListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/access_grants/list'>>>;
type SeamCustomerV1AccessGrantsListRequest = SeamHttpRequest<SeamCustomerV1AccessGrantsListResponse, 'access_grants'>;
interface SeamCustomerV1AccessGrantsListOptions {
}
type SeamCustomerV1AccessGrantsUpdateParameters = RouteRequestBody<'/seam/customer/v1/access_grants/update'>;
/**
 * @deprecated Use SeamCustomerV1AccessGrantsUpdateParameters instead.
 */
type SeamCustomerV1AccessGrantsUpdateBody = SeamCustomerV1AccessGrantsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1AccessGrantsUpdateRequest instead.
 */
type SeamCustomerV1AccessGrantsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/access_grants/update'>>>;
type SeamCustomerV1AccessGrantsUpdateRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1AccessGrantsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1AccessMethods {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1AccessMethods;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1AccessMethods;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1AccessMethods;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1AccessMethods>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AccessMethods;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AccessMethods;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    encode(parameters?: SeamCustomerV1AccessMethodsEncodeParameters, options?: SeamCustomerV1AccessMethodsEncodeOptions): SeamCustomerV1AccessMethodsEncodeRequest;
}
type SeamCustomerV1AccessMethodsEncodeParameters = RouteRequestBody<'/seam/customer/v1/access_methods/encode'>;
/**
 * @deprecated Use SeamCustomerV1AccessMethodsEncodeParameters instead.
 */
type SeamCustomerV1AccessMethodsEncodeBody = SeamCustomerV1AccessMethodsEncodeParameters;
/**
 * @deprecated Use SeamCustomerV1AccessMethodsEncodeRequest instead.
 */
type SeamCustomerV1AccessMethodsEncodeResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/access_methods/encode'>>>;
type SeamCustomerV1AccessMethodsEncodeRequest = SeamHttpRequest<SeamCustomerV1AccessMethodsEncodeResponse, 'action_attempt'>;
type SeamCustomerV1AccessMethodsEncodeOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpSeamCustomerV1AutomationRuns {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1AutomationRuns;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1AutomationRuns;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1AutomationRuns;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1AutomationRuns>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AutomationRuns;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1AutomationRuns;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: SeamCustomerV1AutomationRunsListParameters, options?: SeamCustomerV1AutomationRunsListOptions): SeamCustomerV1AutomationRunsListRequest;
}
type SeamCustomerV1AutomationRunsListParameters = RouteRequestBody<'/seam/customer/v1/automation_runs/list'>;
/**
 * @deprecated Use SeamCustomerV1AutomationRunsListParameters instead.
 */
type SeamCustomerV1AutomationRunsListParams = SeamCustomerV1AutomationRunsListParameters;
/**
 * @deprecated Use SeamCustomerV1AutomationRunsListRequest instead.
 */
type SeamCustomerV1AutomationRunsListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/automation_runs/list'>>>;
type SeamCustomerV1AutomationRunsListRequest = SeamHttpRequest<SeamCustomerV1AutomationRunsListResponse, 'automation_runs'>;
interface SeamCustomerV1AutomationRunsListOptions {
}

declare class SeamHttpSeamCustomerV1Automations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Automations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Automations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Automations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Automations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Automations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Automations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    delete(parameters?: SeamCustomerV1AutomationsDeleteParameters, options?: SeamCustomerV1AutomationsDeleteOptions): SeamCustomerV1AutomationsDeleteRequest;
    get(parameters?: SeamCustomerV1AutomationsGetParameters, options?: SeamCustomerV1AutomationsGetOptions): SeamCustomerV1AutomationsGetRequest;
    update(parameters?: SeamCustomerV1AutomationsUpdateParameters, options?: SeamCustomerV1AutomationsUpdateOptions): SeamCustomerV1AutomationsUpdateRequest;
}
type SeamCustomerV1AutomationsDeleteParameters = RouteRequestBody<'/seam/customer/v1/automations/delete'>;
/**
 * @deprecated Use SeamCustomerV1AutomationsDeleteParameters instead.
 */
type SeamCustomerV1AutomationsDeleteParams = SeamCustomerV1AutomationsDeleteParameters;
/**
 * @deprecated Use SeamCustomerV1AutomationsDeleteRequest instead.
 */
type SeamCustomerV1AutomationsDeleteResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/automations/delete'>>>;
type SeamCustomerV1AutomationsDeleteRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1AutomationsDeleteOptions {
}
type SeamCustomerV1AutomationsGetParameters = RouteRequestBody<'/seam/customer/v1/automations/get'>;
/**
 * @deprecated Use SeamCustomerV1AutomationsGetParameters instead.
 */
type SeamCustomerV1AutomationsGetParams = SeamCustomerV1AutomationsGetParameters;
/**
 * @deprecated Use SeamCustomerV1AutomationsGetRequest instead.
 */
type SeamCustomerV1AutomationsGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/automations/get'>>>;
type SeamCustomerV1AutomationsGetRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1AutomationsGetOptions {
}
type SeamCustomerV1AutomationsUpdateParameters = RouteRequestBody<'/seam/customer/v1/automations/update'>;
/**
 * @deprecated Use SeamCustomerV1AutomationsUpdateParameters instead.
 */
type SeamCustomerV1AutomationsUpdateBody = SeamCustomerV1AutomationsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1AutomationsUpdateRequest instead.
 */
type SeamCustomerV1AutomationsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/automations/update'>>>;
type SeamCustomerV1AutomationsUpdateRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1AutomationsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1ConnectorCustomers {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1ConnectorCustomers;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1ConnectorCustomers;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1ConnectorCustomers;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1ConnectorCustomers>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1ConnectorCustomers;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1ConnectorCustomers;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: SeamCustomerV1ConnectorCustomersListParameters, options?: SeamCustomerV1ConnectorCustomersListOptions): SeamCustomerV1ConnectorCustomersListRequest;
}
type SeamCustomerV1ConnectorCustomersListParameters = RouteRequestBody<'/seam/customer/v1/connector_customers/list'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorCustomersListParameters instead.
 */
type SeamCustomerV1ConnectorCustomersListParams = SeamCustomerV1ConnectorCustomersListParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorCustomersListRequest instead.
 */
type SeamCustomerV1ConnectorCustomersListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connector_customers/list'>>>;
type SeamCustomerV1ConnectorCustomersListRequest = SeamHttpRequest<SeamCustomerV1ConnectorCustomersListResponse, 'connector_customers'>;
interface SeamCustomerV1ConnectorCustomersListOptions {
}

declare class SeamHttpSeamCustomerV1ConnectorsIcal {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1ConnectorsIcal;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1ConnectorsIcal;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1ConnectorsIcal;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1ConnectorsIcal>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1ConnectorsIcal;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1ConnectorsIcal;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    validateConfig(parameters?: SeamCustomerV1ConnectorsIcalValidateConfigParameters, options?: SeamCustomerV1ConnectorsIcalValidateConfigOptions): SeamCustomerV1ConnectorsIcalValidateConfigRequest;
}
type SeamCustomerV1ConnectorsIcalValidateConfigParameters = RouteRequestBody<'/seam/customer/v1/connectors/ical/validate-config'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsIcalValidateConfigParameters instead.
 */
type SeamCustomerV1ConnectorsIcalValidateConfigBody = SeamCustomerV1ConnectorsIcalValidateConfigParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsIcalValidateConfigRequest instead.
 */
type SeamCustomerV1ConnectorsIcalValidateConfigResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/ical/validate-config'>>>;
type SeamCustomerV1ConnectorsIcalValidateConfigRequest = SeamHttpRequest<SeamCustomerV1ConnectorsIcalValidateConfigResponse, 'validation_result'>;
interface SeamCustomerV1ConnectorsIcalValidateConfigOptions {
}

declare class SeamHttpSeamCustomerV1Connectors {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Connectors;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Connectors;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Connectors;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Connectors>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Connectors;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Connectors;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get ical(): SeamHttpSeamCustomerV1ConnectorsIcal;
    authorize(parameters?: SeamCustomerV1ConnectorsAuthorizeParameters, options?: SeamCustomerV1ConnectorsAuthorizeOptions): SeamCustomerV1ConnectorsAuthorizeRequest;
    connectorTypes(parameters?: SeamCustomerV1ConnectorsConnectorTypesParameters, options?: SeamCustomerV1ConnectorsConnectorTypesOptions): SeamCustomerV1ConnectorsConnectorTypesRequest;
    create(parameters?: SeamCustomerV1ConnectorsCreateParameters, options?: SeamCustomerV1ConnectorsCreateOptions): SeamCustomerV1ConnectorsCreateRequest;
    delete(parameters?: SeamCustomerV1ConnectorsDeleteParameters, options?: SeamCustomerV1ConnectorsDeleteOptions): SeamCustomerV1ConnectorsDeleteRequest;
    list(parameters?: SeamCustomerV1ConnectorsListParameters, options?: SeamCustomerV1ConnectorsListOptions): SeamCustomerV1ConnectorsListRequest;
    sync(parameters?: SeamCustomerV1ConnectorsSyncParameters, options?: SeamCustomerV1ConnectorsSyncOptions): SeamCustomerV1ConnectorsSyncRequest;
    update(parameters?: SeamCustomerV1ConnectorsUpdateParameters, options?: SeamCustomerV1ConnectorsUpdateOptions): SeamCustomerV1ConnectorsUpdateRequest;
}
type SeamCustomerV1ConnectorsAuthorizeParameters = RouteRequestBody<'/seam/customer/v1/connectors/authorize'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsAuthorizeParameters instead.
 */
type SeamCustomerV1ConnectorsAuthorizeParams = SeamCustomerV1ConnectorsAuthorizeParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsAuthorizeRequest instead.
 */
type SeamCustomerV1ConnectorsAuthorizeResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/authorize'>>>;
type SeamCustomerV1ConnectorsAuthorizeRequest = SeamHttpRequest<SeamCustomerV1ConnectorsAuthorizeResponse, 'connector_authorize'>;
interface SeamCustomerV1ConnectorsAuthorizeOptions {
}
type SeamCustomerV1ConnectorsConnectorTypesParameters = RouteRequestParams<'/seam/customer/v1/connectors/connector_types'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsConnectorTypesParameters instead.
 */
type SeamCustomerV1ConnectorsConnectorTypesParams = SeamCustomerV1ConnectorsConnectorTypesParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsConnectorTypesRequest instead.
 */
type SeamCustomerV1ConnectorsConnectorTypesResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/connector_types'>>>;
type SeamCustomerV1ConnectorsConnectorTypesRequest = SeamHttpRequest<SeamCustomerV1ConnectorsConnectorTypesResponse, 'connector_types'>;
interface SeamCustomerV1ConnectorsConnectorTypesOptions {
}
type SeamCustomerV1ConnectorsCreateParameters = RouteRequestBody<'/seam/customer/v1/connectors/create'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsCreateParameters instead.
 */
type SeamCustomerV1ConnectorsCreateBody = SeamCustomerV1ConnectorsCreateParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsCreateRequest instead.
 */
type SeamCustomerV1ConnectorsCreateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/create'>>>;
type SeamCustomerV1ConnectorsCreateRequest = SeamHttpRequest<SeamCustomerV1ConnectorsCreateResponse, 'connector'>;
interface SeamCustomerV1ConnectorsCreateOptions {
}
type SeamCustomerV1ConnectorsDeleteParameters = RouteRequestBody<'/seam/customer/v1/connectors/delete'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsDeleteParameters instead.
 */
type SeamCustomerV1ConnectorsDeleteBody = SeamCustomerV1ConnectorsDeleteParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsDeleteRequest instead.
 */
type SeamCustomerV1ConnectorsDeleteResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/delete'>>>;
type SeamCustomerV1ConnectorsDeleteRequest = SeamHttpRequest<SeamCustomerV1ConnectorsDeleteResponse, 'connector'>;
interface SeamCustomerV1ConnectorsDeleteOptions {
}
type SeamCustomerV1ConnectorsListParameters = RouteRequestParams<'/seam/customer/v1/connectors/list'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsListParameters instead.
 */
type SeamCustomerV1ConnectorsListParams = SeamCustomerV1ConnectorsListParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsListRequest instead.
 */
type SeamCustomerV1ConnectorsListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/list'>>>;
type SeamCustomerV1ConnectorsListRequest = SeamHttpRequest<SeamCustomerV1ConnectorsListResponse, 'connectors'>;
interface SeamCustomerV1ConnectorsListOptions {
}
type SeamCustomerV1ConnectorsSyncParameters = RouteRequestBody<'/seam/customer/v1/connectors/sync'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsSyncParameters instead.
 */
type SeamCustomerV1ConnectorsSyncBody = SeamCustomerV1ConnectorsSyncParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsSyncRequest instead.
 */
type SeamCustomerV1ConnectorsSyncResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/sync'>>>;
type SeamCustomerV1ConnectorsSyncRequest = SeamHttpRequest<SeamCustomerV1ConnectorsSyncResponse, 'connector_sync'>;
interface SeamCustomerV1ConnectorsSyncOptions {
}
type SeamCustomerV1ConnectorsUpdateParameters = RouteRequestBody<'/seam/customer/v1/connectors/update'>;
/**
 * @deprecated Use SeamCustomerV1ConnectorsUpdateParameters instead.
 */
type SeamCustomerV1ConnectorsUpdateBody = SeamCustomerV1ConnectorsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1ConnectorsUpdateRequest instead.
 */
type SeamCustomerV1ConnectorsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/connectors/update'>>>;
type SeamCustomerV1ConnectorsUpdateRequest = SeamHttpRequest<SeamCustomerV1ConnectorsUpdateResponse, 'connector'>;
interface SeamCustomerV1ConnectorsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1CustomersAutomations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1CustomersAutomations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1CustomersAutomations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1CustomersAutomations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1CustomersAutomations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1CustomersAutomations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1CustomersAutomations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamCustomerV1CustomersAutomationsGetParameters, options?: SeamCustomerV1CustomersAutomationsGetOptions): SeamCustomerV1CustomersAutomationsGetRequest;
    update(parameters?: SeamCustomerV1CustomersAutomationsUpdateParameters, options?: SeamCustomerV1CustomersAutomationsUpdateOptions): SeamCustomerV1CustomersAutomationsUpdateRequest;
}
type SeamCustomerV1CustomersAutomationsGetParameters = RouteRequestParams<'/seam/customer/v1/customers/automations/get'>;
/**
 * @deprecated Use SeamCustomerV1CustomersAutomationsGetParameters instead.
 */
type SeamCustomerV1CustomersAutomationsGetParams = SeamCustomerV1CustomersAutomationsGetParameters;
/**
 * @deprecated Use SeamCustomerV1CustomersAutomationsGetRequest instead.
 */
type SeamCustomerV1CustomersAutomationsGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/customers/automations/get'>>>;
type SeamCustomerV1CustomersAutomationsGetRequest = SeamHttpRequest<SeamCustomerV1CustomersAutomationsGetResponse, 'automation'>;
interface SeamCustomerV1CustomersAutomationsGetOptions {
}
type SeamCustomerV1CustomersAutomationsUpdateParameters = RouteRequestBody<'/seam/customer/v1/customers/automations/update'>;
/**
 * @deprecated Use SeamCustomerV1CustomersAutomationsUpdateParameters instead.
 */
type SeamCustomerV1CustomersAutomationsUpdateBody = SeamCustomerV1CustomersAutomationsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1CustomersAutomationsUpdateRequest instead.
 */
type SeamCustomerV1CustomersAutomationsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/customers/automations/update'>>>;
type SeamCustomerV1CustomersAutomationsUpdateRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1CustomersAutomationsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1Customers {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Customers;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Customers;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Customers;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Customers>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Customers;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Customers;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get automations(): SeamHttpSeamCustomerV1CustomersAutomations;
    list(parameters?: SeamCustomerV1CustomersListParameters, options?: SeamCustomerV1CustomersListOptions): SeamCustomerV1CustomersListRequest;
    me(parameters?: SeamCustomerV1CustomersMeParameters, options?: SeamCustomerV1CustomersMeOptions): SeamCustomerV1CustomersMeRequest;
    openPortal(parameters?: SeamCustomerV1CustomersOpenPortalParameters, options?: SeamCustomerV1CustomersOpenPortalOptions): SeamCustomerV1CustomersOpenPortalRequest;
}
type SeamCustomerV1CustomersListParameters = RouteRequestBody<'/seam/customer/v1/customers/list'>;
/**
 * @deprecated Use SeamCustomerV1CustomersListParameters instead.
 */
type SeamCustomerV1CustomersListParams = SeamCustomerV1CustomersListParameters;
/**
 * @deprecated Use SeamCustomerV1CustomersListRequest instead.
 */
type SeamCustomerV1CustomersListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/customers/list'>>>;
type SeamCustomerV1CustomersListRequest = SeamHttpRequest<SeamCustomerV1CustomersListResponse, 'customers'>;
interface SeamCustomerV1CustomersListOptions {
}
type SeamCustomerV1CustomersMeParameters = RouteRequestParams<'/seam/customer/v1/customers/me'>;
/**
 * @deprecated Use SeamCustomerV1CustomersMeParameters instead.
 */
type SeamCustomerV1CustomersMeParams = SeamCustomerV1CustomersMeParameters;
/**
 * @deprecated Use SeamCustomerV1CustomersMeRequest instead.
 */
type SeamCustomerV1CustomersMeResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/customers/me'>>>;
type SeamCustomerV1CustomersMeRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1CustomersMeOptions {
}
type SeamCustomerV1CustomersOpenPortalParameters = RouteRequestBody<'/seam/customer/v1/customers/open_portal'>;
/**
 * @deprecated Use SeamCustomerV1CustomersOpenPortalParameters instead.
 */
type SeamCustomerV1CustomersOpenPortalBody = SeamCustomerV1CustomersOpenPortalParameters;
/**
 * @deprecated Use SeamCustomerV1CustomersOpenPortalRequest instead.
 */
type SeamCustomerV1CustomersOpenPortalResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/customers/open_portal'>>>;
type SeamCustomerV1CustomersOpenPortalRequest = SeamHttpRequest<SeamCustomerV1CustomersOpenPortalResponse, 'magic_link'>;
interface SeamCustomerV1CustomersOpenPortalOptions {
}

declare class SeamHttpSeamCustomerV1Encoders {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Encoders;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Encoders;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Encoders;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Encoders>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Encoders;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Encoders;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: SeamCustomerV1EncodersListParameters, options?: SeamCustomerV1EncodersListOptions): SeamCustomerV1EncodersListRequest;
}
type SeamCustomerV1EncodersListParameters = RouteRequestBody<'/seam/customer/v1/encoders/list'>;
/**
 * @deprecated Use SeamCustomerV1EncodersListParameters instead.
 */
type SeamCustomerV1EncodersListParams = SeamCustomerV1EncodersListParameters;
/**
 * @deprecated Use SeamCustomerV1EncodersListRequest instead.
 */
type SeamCustomerV1EncodersListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/encoders/list'>>>;
type SeamCustomerV1EncodersListRequest = SeamHttpRequest<SeamCustomerV1EncodersListResponse, 'encoders'>;
interface SeamCustomerV1EncodersListOptions {
}

declare class SeamHttpSeamCustomerV1Events {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Events;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Events;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Events;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Events>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Events;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Events;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    list(parameters?: SeamCustomerV1EventsListParameters, options?: SeamCustomerV1EventsListOptions): SeamCustomerV1EventsListRequest;
}
type SeamCustomerV1EventsListParameters = RouteRequestBody<'/seam/customer/v1/events/list'>;
/**
 * @deprecated Use SeamCustomerV1EventsListParameters instead.
 */
type SeamCustomerV1EventsListParams = SeamCustomerV1EventsListParameters;
/**
 * @deprecated Use SeamCustomerV1EventsListRequest instead.
 */
type SeamCustomerV1EventsListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/events/list'>>>;
type SeamCustomerV1EventsListRequest = SeamHttpRequest<SeamCustomerV1EventsListResponse, 'events'>;
interface SeamCustomerV1EventsListOptions {
}

declare class SeamHttpSeamCustomerV1Portals {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Portals;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Portals;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Portals;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Portals>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Portals;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Portals;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamCustomerV1PortalsGetParameters, options?: SeamCustomerV1PortalsGetOptions): SeamCustomerV1PortalsGetRequest;
    update(parameters?: SeamCustomerV1PortalsUpdateParameters, options?: SeamCustomerV1PortalsUpdateOptions): SeamCustomerV1PortalsUpdateRequest;
}
type SeamCustomerV1PortalsGetParameters = RouteRequestBody<'/seam/customer/v1/portals/get'>;
/**
 * @deprecated Use SeamCustomerV1PortalsGetParameters instead.
 */
type SeamCustomerV1PortalsGetParams = SeamCustomerV1PortalsGetParameters;
/**
 * @deprecated Use SeamCustomerV1PortalsGetRequest instead.
 */
type SeamCustomerV1PortalsGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/portals/get'>>>;
type SeamCustomerV1PortalsGetRequest = SeamHttpRequest<SeamCustomerV1PortalsGetResponse, 'customer_portal'>;
interface SeamCustomerV1PortalsGetOptions {
}
type SeamCustomerV1PortalsUpdateParameters = RouteRequestBody<'/seam/customer/v1/portals/update'>;
/**
 * @deprecated Use SeamCustomerV1PortalsUpdateParameters instead.
 */
type SeamCustomerV1PortalsUpdateBody = SeamCustomerV1PortalsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1PortalsUpdateRequest instead.
 */
type SeamCustomerV1PortalsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/portals/update'>>>;
type SeamCustomerV1PortalsUpdateRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1PortalsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1Reservations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Reservations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Reservations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Reservations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Reservations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Reservations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Reservations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamCustomerV1ReservationsGetParameters, options?: SeamCustomerV1ReservationsGetOptions): SeamCustomerV1ReservationsGetRequest;
    list(parameters?: SeamCustomerV1ReservationsListParameters, options?: SeamCustomerV1ReservationsListOptions): SeamCustomerV1ReservationsListRequest;
    listAccessGrants(parameters?: SeamCustomerV1ReservationsListAccessGrantsParameters, options?: SeamCustomerV1ReservationsListAccessGrantsOptions): SeamCustomerV1ReservationsListAccessGrantsRequest;
}
type SeamCustomerV1ReservationsGetParameters = RouteRequestBody<'/seam/customer/v1/reservations/get'>;
/**
 * @deprecated Use SeamCustomerV1ReservationsGetParameters instead.
 */
type SeamCustomerV1ReservationsGetParams = SeamCustomerV1ReservationsGetParameters;
/**
 * @deprecated Use SeamCustomerV1ReservationsGetRequest instead.
 */
type SeamCustomerV1ReservationsGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/reservations/get'>>>;
type SeamCustomerV1ReservationsGetRequest = SeamHttpRequest<SeamCustomerV1ReservationsGetResponse, 'reservation'>;
interface SeamCustomerV1ReservationsGetOptions {
}
type SeamCustomerV1ReservationsListParameters = RouteRequestBody<'/seam/customer/v1/reservations/list'>;
/**
 * @deprecated Use SeamCustomerV1ReservationsListParameters instead.
 */
type SeamCustomerV1ReservationsListParams = SeamCustomerV1ReservationsListParameters;
/**
 * @deprecated Use SeamCustomerV1ReservationsListRequest instead.
 */
type SeamCustomerV1ReservationsListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/reservations/list'>>>;
type SeamCustomerV1ReservationsListRequest = SeamHttpRequest<SeamCustomerV1ReservationsListResponse, 'reservations'>;
interface SeamCustomerV1ReservationsListOptions {
}
type SeamCustomerV1ReservationsListAccessGrantsParameters = RouteRequestBody<'/seam/customer/v1/reservations/list_access_grants'>;
/**
 * @deprecated Use SeamCustomerV1ReservationsListAccessGrantsParameters instead.
 */
type SeamCustomerV1ReservationsListAccessGrantsParams = SeamCustomerV1ReservationsListAccessGrantsParameters;
/**
 * @deprecated Use SeamCustomerV1ReservationsListAccessGrantsRequest instead.
 */
type SeamCustomerV1ReservationsListAccessGrantsResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/reservations/list_access_grants'>>>;
type SeamCustomerV1ReservationsListAccessGrantsRequest = SeamHttpRequest<SeamCustomerV1ReservationsListAccessGrantsResponse, 'access_grants'>;
interface SeamCustomerV1ReservationsListAccessGrantsOptions {
}

declare class SeamHttpSeamCustomerV1SettingsVerticalResourceAliases {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1SettingsVerticalResourceAliases>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamCustomerV1SettingsVerticalResourceAliasesGetParameters, options?: SeamCustomerV1SettingsVerticalResourceAliasesGetOptions): SeamCustomerV1SettingsVerticalResourceAliasesGetRequest;
}
type SeamCustomerV1SettingsVerticalResourceAliasesGetParameters = RouteRequestBody<'/seam/customer/v1/settings/vertical_resource_aliases/get'>;
/**
 * @deprecated Use SeamCustomerV1SettingsVerticalResourceAliasesGetParameters instead.
 */
type SeamCustomerV1SettingsVerticalResourceAliasesGetParams = SeamCustomerV1SettingsVerticalResourceAliasesGetParameters;
/**
 * @deprecated Use SeamCustomerV1SettingsVerticalResourceAliasesGetRequest instead.
 */
type SeamCustomerV1SettingsVerticalResourceAliasesGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/settings/vertical_resource_aliases/get'>>>;
type SeamCustomerV1SettingsVerticalResourceAliasesGetRequest = SeamHttpRequest<SeamCustomerV1SettingsVerticalResourceAliasesGetResponse, 'vertical_resource_aliases'>;
interface SeamCustomerV1SettingsVerticalResourceAliasesGetOptions {
}

declare class SeamHttpSeamCustomerV1Settings {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Settings;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Settings;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Settings;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Settings>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Settings;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Settings;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get verticalResourceAliases(): SeamHttpSeamCustomerV1SettingsVerticalResourceAliases;
    get(parameters?: SeamCustomerV1SettingsGetParameters, options?: SeamCustomerV1SettingsGetOptions): SeamCustomerV1SettingsGetRequest;
    update(parameters?: SeamCustomerV1SettingsUpdateParameters, options?: SeamCustomerV1SettingsUpdateOptions): SeamCustomerV1SettingsUpdateRequest;
}
type SeamCustomerV1SettingsGetParameters = RouteRequestParams<'/seam/customer/v1/settings/get'>;
/**
 * @deprecated Use SeamCustomerV1SettingsGetParameters instead.
 */
type SeamCustomerV1SettingsGetParams = SeamCustomerV1SettingsGetParameters;
/**
 * @deprecated Use SeamCustomerV1SettingsGetRequest instead.
 */
type SeamCustomerV1SettingsGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/settings/get'>>>;
type SeamCustomerV1SettingsGetRequest = SeamHttpRequest<SeamCustomerV1SettingsGetResponse, 'business_vertical'>;
interface SeamCustomerV1SettingsGetOptions {
}
type SeamCustomerV1SettingsUpdateParameters = RouteRequestBody<'/seam/customer/v1/settings/update'>;
/**
 * @deprecated Use SeamCustomerV1SettingsUpdateParameters instead.
 */
type SeamCustomerV1SettingsUpdateBody = SeamCustomerV1SettingsUpdateParameters;
/**
 * @deprecated Use SeamCustomerV1SettingsUpdateRequest instead.
 */
type SeamCustomerV1SettingsUpdateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/settings/update'>>>;
type SeamCustomerV1SettingsUpdateRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1SettingsUpdateOptions {
}

declare class SeamHttpSeamCustomerV1Spaces {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1Spaces;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1Spaces;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1Spaces;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1Spaces>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Spaces;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1Spaces;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: SeamCustomerV1SpacesCreateParameters, options?: SeamCustomerV1SpacesCreateOptions): SeamCustomerV1SpacesCreateRequest;
    list(parameters?: SeamCustomerV1SpacesListParameters, options?: SeamCustomerV1SpacesListOptions): SeamCustomerV1SpacesListRequest;
    listReservations(parameters?: SeamCustomerV1SpacesListReservationsParameters, options?: SeamCustomerV1SpacesListReservationsOptions): SeamCustomerV1SpacesListReservationsRequest;
    pushCommonAreas(parameters?: SeamCustomerV1SpacesPushCommonAreasParameters, options?: SeamCustomerV1SpacesPushCommonAreasOptions): SeamCustomerV1SpacesPushCommonAreasRequest;
}
type SeamCustomerV1SpacesCreateParameters = RouteRequestBody<'/seam/customer/v1/spaces/create'>;
/**
 * @deprecated Use SeamCustomerV1SpacesCreateParameters instead.
 */
type SeamCustomerV1SpacesCreateBody = SeamCustomerV1SpacesCreateParameters;
/**
 * @deprecated Use SeamCustomerV1SpacesCreateRequest instead.
 */
type SeamCustomerV1SpacesCreateResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/spaces/create'>>>;
type SeamCustomerV1SpacesCreateRequest = SeamHttpRequest<SeamCustomerV1SpacesCreateResponse, 'space'>;
interface SeamCustomerV1SpacesCreateOptions {
}
type SeamCustomerV1SpacesListParameters = RouteRequestBody<'/seam/customer/v1/spaces/list'>;
/**
 * @deprecated Use SeamCustomerV1SpacesListParameters instead.
 */
type SeamCustomerV1SpacesListParams = SeamCustomerV1SpacesListParameters;
/**
 * @deprecated Use SeamCustomerV1SpacesListRequest instead.
 */
type SeamCustomerV1SpacesListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/spaces/list'>>>;
type SeamCustomerV1SpacesListRequest = SeamHttpRequest<SeamCustomerV1SpacesListResponse, 'spaces'>;
interface SeamCustomerV1SpacesListOptions {
}
type SeamCustomerV1SpacesListReservationsParameters = RouteRequestBody<'/seam/customer/v1/spaces/list_reservations'>;
/**
 * @deprecated Use SeamCustomerV1SpacesListReservationsParameters instead.
 */
type SeamCustomerV1SpacesListReservationsParams = SeamCustomerV1SpacesListReservationsParameters;
/**
 * @deprecated Use SeamCustomerV1SpacesListReservationsRequest instead.
 */
type SeamCustomerV1SpacesListReservationsResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/spaces/list_reservations'>>>;
type SeamCustomerV1SpacesListReservationsRequest = SeamHttpRequest<SeamCustomerV1SpacesListReservationsResponse, 'reservations'>;
interface SeamCustomerV1SpacesListReservationsOptions {
}
type SeamCustomerV1SpacesPushCommonAreasParameters = RouteRequestBody<'/seam/customer/v1/spaces/push_common_areas'>;
/**
 * @deprecated Use SeamCustomerV1SpacesPushCommonAreasParameters instead.
 */
type SeamCustomerV1SpacesPushCommonAreasBody = SeamCustomerV1SpacesPushCommonAreasParameters;
/**
 * @deprecated Use SeamCustomerV1SpacesPushCommonAreasRequest instead.
 */
type SeamCustomerV1SpacesPushCommonAreasResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/spaces/push_common_areas'>>>;
type SeamCustomerV1SpacesPushCommonAreasRequest = SeamHttpRequest<void, undefined>;
interface SeamCustomerV1SpacesPushCommonAreasOptions {
}

declare class SeamHttpSeamCustomerV1StaffMembers {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1StaffMembers;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1StaffMembers;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1StaffMembers;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1StaffMembers>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1StaffMembers;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1StaffMembers;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: SeamCustomerV1StaffMembersGetParameters, options?: SeamCustomerV1StaffMembersGetOptions): SeamCustomerV1StaffMembersGetRequest;
    list(parameters?: SeamCustomerV1StaffMembersListParameters, options?: SeamCustomerV1StaffMembersListOptions): SeamCustomerV1StaffMembersListRequest;
}
type SeamCustomerV1StaffMembersGetParameters = RouteRequestBody<'/seam/customer/v1/staff_members/get'>;
/**
 * @deprecated Use SeamCustomerV1StaffMembersGetParameters instead.
 */
type SeamCustomerV1StaffMembersGetParams = SeamCustomerV1StaffMembersGetParameters;
/**
 * @deprecated Use SeamCustomerV1StaffMembersGetRequest instead.
 */
type SeamCustomerV1StaffMembersGetResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/staff_members/get'>>>;
type SeamCustomerV1StaffMembersGetRequest = SeamHttpRequest<SeamCustomerV1StaffMembersGetResponse, 'staff_member'>;
interface SeamCustomerV1StaffMembersGetOptions {
}
type SeamCustomerV1StaffMembersListParameters = RouteRequestBody<'/seam/customer/v1/staff_members/list'>;
/**
 * @deprecated Use SeamCustomerV1StaffMembersListParameters instead.
 */
type SeamCustomerV1StaffMembersListParams = SeamCustomerV1StaffMembersListParameters;
/**
 * @deprecated Use SeamCustomerV1StaffMembersListRequest instead.
 */
type SeamCustomerV1StaffMembersListResponse = SetNonNullable<Required<RouteResponse<'/seam/customer/v1/staff_members/list'>>>;
type SeamCustomerV1StaffMembersListRequest = SeamHttpRequest<SeamCustomerV1StaffMembersListResponse, 'staff_members'>;
interface SeamCustomerV1StaffMembersListOptions {
}

declare class SeamHttpSeamCustomerV1 {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamCustomerV1;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamCustomerV1;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamCustomerV1;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamCustomerV1>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamCustomerV1;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamCustomerV1;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get accessGrants(): SeamHttpSeamCustomerV1AccessGrants;
    get accessMethods(): SeamHttpSeamCustomerV1AccessMethods;
    get automationRuns(): SeamHttpSeamCustomerV1AutomationRuns;
    get automations(): SeamHttpSeamCustomerV1Automations;
    get connectorCustomers(): SeamHttpSeamCustomerV1ConnectorCustomers;
    get connectors(): SeamHttpSeamCustomerV1Connectors;
    get customers(): SeamHttpSeamCustomerV1Customers;
    get encoders(): SeamHttpSeamCustomerV1Encoders;
    get events(): SeamHttpSeamCustomerV1Events;
    get portals(): SeamHttpSeamCustomerV1Portals;
    get reservations(): SeamHttpSeamCustomerV1Reservations;
    get settings(): SeamHttpSeamCustomerV1Settings;
    get spaces(): SeamHttpSeamCustomerV1Spaces;
    get staffMembers(): SeamHttpSeamCustomerV1StaffMembers;
}

declare class SeamHttpSeamPartnerV1BuildingBlocksSpaces {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamPartnerV1BuildingBlocksSpaces>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    autoMap(parameters?: SeamPartnerV1BuildingBlocksSpacesAutoMapParameters, options?: SeamPartnerV1BuildingBlocksSpacesAutoMapOptions): SeamPartnerV1BuildingBlocksSpacesAutoMapRequest;
}
type SeamPartnerV1BuildingBlocksSpacesAutoMapParameters = RouteRequestBody<'/seam/partner/v1/building_blocks/spaces/auto_map'>;
/**
 * @deprecated Use SeamPartnerV1BuildingBlocksSpacesAutoMapParameters instead.
 */
type SeamPartnerV1BuildingBlocksSpacesAutoMapParams = SeamPartnerV1BuildingBlocksSpacesAutoMapParameters;
/**
 * @deprecated Use SeamPartnerV1BuildingBlocksSpacesAutoMapRequest instead.
 */
type SeamPartnerV1BuildingBlocksSpacesAutoMapResponse = SetNonNullable<Required<RouteResponse<'/seam/partner/v1/building_blocks/spaces/auto_map'>>>;
type SeamPartnerV1BuildingBlocksSpacesAutoMapRequest = SeamHttpRequest<SeamPartnerV1BuildingBlocksSpacesAutoMapResponse, 'spaces'>;
interface SeamPartnerV1BuildingBlocksSpacesAutoMapOptions {
}

declare class SeamHttpSeamPartnerV1BuildingBlocks {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSeamPartnerV1BuildingBlocks;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSeamPartnerV1BuildingBlocks;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSeamPartnerV1BuildingBlocks;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSeamPartnerV1BuildingBlocks>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSeamPartnerV1BuildingBlocks;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSeamPartnerV1BuildingBlocks;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get spaces(): SeamHttpSeamPartnerV1BuildingBlocksSpaces;
}

declare class SeamHttpSpaces {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpSpaces;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpSpaces;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpSpaces;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpSpaces>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpSpaces;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpSpaces;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    addAcsEntrances(parameters?: SpacesAddAcsEntrancesParameters, options?: SpacesAddAcsEntrancesOptions): SpacesAddAcsEntrancesRequest;
    addConnectedAccount(parameters?: SpacesAddConnectedAccountParameters, options?: SpacesAddConnectedAccountOptions): SpacesAddConnectedAccountRequest;
    addDevices(parameters?: SpacesAddDevicesParameters, options?: SpacesAddDevicesOptions): SpacesAddDevicesRequest;
    create(parameters?: SpacesCreateParameters, options?: SpacesCreateOptions): SpacesCreateRequest;
    delete(parameters?: SpacesDeleteParameters, options?: SpacesDeleteOptions): SpacesDeleteRequest;
    get(parameters?: SpacesGetParameters, options?: SpacesGetOptions): SpacesGetRequest;
    getRelated(parameters?: SpacesGetRelatedParameters, options?: SpacesGetRelatedOptions): SpacesGetRelatedRequest;
    list(parameters?: SpacesListParameters, options?: SpacesListOptions): SpacesListRequest;
    removeAcsEntrances(parameters?: SpacesRemoveAcsEntrancesParameters, options?: SpacesRemoveAcsEntrancesOptions): SpacesRemoveAcsEntrancesRequest;
    removeConnectedAccount(parameters?: SpacesRemoveConnectedAccountParameters, options?: SpacesRemoveConnectedAccountOptions): SpacesRemoveConnectedAccountRequest;
    removeDevices(parameters?: SpacesRemoveDevicesParameters, options?: SpacesRemoveDevicesOptions): SpacesRemoveDevicesRequest;
    update(parameters?: SpacesUpdateParameters, options?: SpacesUpdateOptions): SpacesUpdateRequest;
}
type SpacesAddAcsEntrancesParameters = RouteRequestBody<'/spaces/add_acs_entrances'>;
/**
 * @deprecated Use SpacesAddAcsEntrancesParameters instead.
 */
type SpacesAddAcsEntrancesBody = SpacesAddAcsEntrancesParameters;
/**
 * @deprecated Use SpacesAddAcsEntrancesRequest instead.
 */
type SpacesAddAcsEntrancesResponse = SetNonNullable<Required<RouteResponse<'/spaces/add_acs_entrances'>>>;
type SpacesAddAcsEntrancesRequest = SeamHttpRequest<void, undefined>;
interface SpacesAddAcsEntrancesOptions {
}
type SpacesAddConnectedAccountParameters = RouteRequestBody<'/spaces/add_connected_account'>;
/**
 * @deprecated Use SpacesAddConnectedAccountParameters instead.
 */
type SpacesAddConnectedAccountBody = SpacesAddConnectedAccountParameters;
/**
 * @deprecated Use SpacesAddConnectedAccountRequest instead.
 */
type SpacesAddConnectedAccountResponse = SetNonNullable<Required<RouteResponse<'/spaces/add_connected_account'>>>;
type SpacesAddConnectedAccountRequest = SeamHttpRequest<void, undefined>;
interface SpacesAddConnectedAccountOptions {
}
type SpacesAddDevicesParameters = RouteRequestBody<'/spaces/add_devices'>;
/**
 * @deprecated Use SpacesAddDevicesParameters instead.
 */
type SpacesAddDevicesBody = SpacesAddDevicesParameters;
/**
 * @deprecated Use SpacesAddDevicesRequest instead.
 */
type SpacesAddDevicesResponse = SetNonNullable<Required<RouteResponse<'/spaces/add_devices'>>>;
type SpacesAddDevicesRequest = SeamHttpRequest<void, undefined>;
interface SpacesAddDevicesOptions {
}
type SpacesCreateParameters = RouteRequestBody<'/spaces/create'>;
/**
 * @deprecated Use SpacesCreateParameters instead.
 */
type SpacesCreateBody = SpacesCreateParameters;
/**
 * @deprecated Use SpacesCreateRequest instead.
 */
type SpacesCreateResponse = SetNonNullable<Required<RouteResponse<'/spaces/create'>>>;
type SpacesCreateRequest = SeamHttpRequest<SpacesCreateResponse, 'space'>;
interface SpacesCreateOptions {
}
type SpacesDeleteParameters = RouteRequestBody<'/spaces/delete'>;
/**
 * @deprecated Use SpacesDeleteParameters instead.
 */
type SpacesDeleteParams = SpacesDeleteParameters;
/**
 * @deprecated Use SpacesDeleteRequest instead.
 */
type SpacesDeleteResponse = SetNonNullable<Required<RouteResponse<'/spaces/delete'>>>;
type SpacesDeleteRequest = SeamHttpRequest<void, undefined>;
interface SpacesDeleteOptions {
}
type SpacesGetParameters = RouteRequestParams<'/spaces/get'>;
/**
 * @deprecated Use SpacesGetParameters instead.
 */
type SpacesGetParams = SpacesGetParameters;
/**
 * @deprecated Use SpacesGetRequest instead.
 */
type SpacesGetResponse = SetNonNullable<Required<RouteResponse<'/spaces/get'>>>;
type SpacesGetRequest = SeamHttpRequest<SpacesGetResponse, 'space'>;
interface SpacesGetOptions {
}
type SpacesGetRelatedParameters = RouteRequestBody<'/spaces/get_related'>;
/**
 * @deprecated Use SpacesGetRelatedParameters instead.
 */
type SpacesGetRelatedParams = SpacesGetRelatedParameters;
/**
 * @deprecated Use SpacesGetRelatedRequest instead.
 */
type SpacesGetRelatedResponse = SetNonNullable<Required<RouteResponse<'/spaces/get_related'>>>;
type SpacesGetRelatedRequest = SeamHttpRequest<SpacesGetRelatedResponse, 'batch'>;
interface SpacesGetRelatedOptions {
}
type SpacesListParameters = RouteRequestBody<'/spaces/list'>;
/**
 * @deprecated Use SpacesListParameters instead.
 */
type SpacesListParams = SpacesListParameters;
/**
 * @deprecated Use SpacesListRequest instead.
 */
type SpacesListResponse = SetNonNullable<Required<RouteResponse<'/spaces/list'>>>;
type SpacesListRequest = SeamHttpRequest<SpacesListResponse, 'spaces'>;
interface SpacesListOptions {
}
type SpacesRemoveAcsEntrancesParameters = RouteRequestBody<'/spaces/remove_acs_entrances'>;
/**
 * @deprecated Use SpacesRemoveAcsEntrancesParameters instead.
 */
type SpacesRemoveAcsEntrancesParams = SpacesRemoveAcsEntrancesParameters;
/**
 * @deprecated Use SpacesRemoveAcsEntrancesRequest instead.
 */
type SpacesRemoveAcsEntrancesResponse = SetNonNullable<Required<RouteResponse<'/spaces/remove_acs_entrances'>>>;
type SpacesRemoveAcsEntrancesRequest = SeamHttpRequest<void, undefined>;
interface SpacesRemoveAcsEntrancesOptions {
}
type SpacesRemoveConnectedAccountParameters = RouteRequestBody<'/spaces/remove_connected_account'>;
/**
 * @deprecated Use SpacesRemoveConnectedAccountParameters instead.
 */
type SpacesRemoveConnectedAccountParams = SpacesRemoveConnectedAccountParameters;
/**
 * @deprecated Use SpacesRemoveConnectedAccountRequest instead.
 */
type SpacesRemoveConnectedAccountResponse = SetNonNullable<Required<RouteResponse<'/spaces/remove_connected_account'>>>;
type SpacesRemoveConnectedAccountRequest = SeamHttpRequest<void, undefined>;
interface SpacesRemoveConnectedAccountOptions {
}
type SpacesRemoveDevicesParameters = RouteRequestBody<'/spaces/remove_devices'>;
/**
 * @deprecated Use SpacesRemoveDevicesParameters instead.
 */
type SpacesRemoveDevicesParams = SpacesRemoveDevicesParameters;
/**
 * @deprecated Use SpacesRemoveDevicesRequest instead.
 */
type SpacesRemoveDevicesResponse = SetNonNullable<Required<RouteResponse<'/spaces/remove_devices'>>>;
type SpacesRemoveDevicesRequest = SeamHttpRequest<void, undefined>;
interface SpacesRemoveDevicesOptions {
}
type SpacesUpdateParameters = RouteRequestBody<'/spaces/update'>;
/**
 * @deprecated Use SpacesUpdateParameters instead.
 */
type SpacesUpdateBody = SpacesUpdateParameters;
/**
 * @deprecated Use SpacesUpdateRequest instead.
 */
type SpacesUpdateResponse = SetNonNullable<Required<RouteResponse<'/spaces/update'>>>;
type SpacesUpdateRequest = SeamHttpRequest<SpacesUpdateResponse, 'space'>;
interface SpacesUpdateOptions {
}

declare class SeamHttpThermostatsDailyPrograms {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostatsDailyPrograms;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostatsDailyPrograms;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostatsDailyPrograms;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostatsDailyPrograms>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpThermostatsDailyPrograms;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpThermostatsDailyPrograms;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: ThermostatsDailyProgramsCreateParameters, options?: ThermostatsDailyProgramsCreateOptions): ThermostatsDailyProgramsCreateRequest;
    delete(parameters?: ThermostatsDailyProgramsDeleteParameters, options?: ThermostatsDailyProgramsDeleteOptions): ThermostatsDailyProgramsDeleteRequest;
    update(parameters?: ThermostatsDailyProgramsUpdateParameters, options?: ThermostatsDailyProgramsUpdateOptions): ThermostatsDailyProgramsUpdateRequest;
}
type ThermostatsDailyProgramsCreateParameters = RouteRequestBody<'/thermostats/daily_programs/create'>;
/**
 * @deprecated Use ThermostatsDailyProgramsCreateParameters instead.
 */
type ThermostatsDailyProgramsCreateBody = ThermostatsDailyProgramsCreateParameters;
/**
 * @deprecated Use ThermostatsDailyProgramsCreateRequest instead.
 */
type ThermostatsDailyProgramsCreateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/daily_programs/create'>>>;
type ThermostatsDailyProgramsCreateRequest = SeamHttpRequest<ThermostatsDailyProgramsCreateResponse, 'thermostat_daily_program'>;
interface ThermostatsDailyProgramsCreateOptions {
}
type ThermostatsDailyProgramsDeleteParameters = RouteRequestBody<'/thermostats/daily_programs/delete'>;
/**
 * @deprecated Use ThermostatsDailyProgramsDeleteParameters instead.
 */
type ThermostatsDailyProgramsDeleteParams = ThermostatsDailyProgramsDeleteParameters;
/**
 * @deprecated Use ThermostatsDailyProgramsDeleteRequest instead.
 */
type ThermostatsDailyProgramsDeleteResponse = SetNonNullable<Required<RouteResponse<'/thermostats/daily_programs/delete'>>>;
type ThermostatsDailyProgramsDeleteRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsDailyProgramsDeleteOptions {
}
type ThermostatsDailyProgramsUpdateParameters = RouteRequestBody<'/thermostats/daily_programs/update'>;
/**
 * @deprecated Use ThermostatsDailyProgramsUpdateParameters instead.
 */
type ThermostatsDailyProgramsUpdateBody = ThermostatsDailyProgramsUpdateParameters;
/**
 * @deprecated Use ThermostatsDailyProgramsUpdateRequest instead.
 */
type ThermostatsDailyProgramsUpdateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/daily_programs/update'>>>;
type ThermostatsDailyProgramsUpdateRequest = SeamHttpRequest<ThermostatsDailyProgramsUpdateResponse, 'action_attempt'>;
type ThermostatsDailyProgramsUpdateOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpThermostatsSchedules {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostatsSchedules;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostatsSchedules;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostatsSchedules;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostatsSchedules>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpThermostatsSchedules;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpThermostatsSchedules;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: ThermostatsSchedulesCreateParameters, options?: ThermostatsSchedulesCreateOptions): ThermostatsSchedulesCreateRequest;
    delete(parameters?: ThermostatsSchedulesDeleteParameters, options?: ThermostatsSchedulesDeleteOptions): ThermostatsSchedulesDeleteRequest;
    get(parameters?: ThermostatsSchedulesGetParameters, options?: ThermostatsSchedulesGetOptions): ThermostatsSchedulesGetRequest;
    list(parameters?: ThermostatsSchedulesListParameters, options?: ThermostatsSchedulesListOptions): ThermostatsSchedulesListRequest;
    update(parameters?: ThermostatsSchedulesUpdateParameters, options?: ThermostatsSchedulesUpdateOptions): ThermostatsSchedulesUpdateRequest;
}
type ThermostatsSchedulesCreateParameters = RouteRequestBody<'/thermostats/schedules/create'>;
/**
 * @deprecated Use ThermostatsSchedulesCreateParameters instead.
 */
type ThermostatsSchedulesCreateBody = ThermostatsSchedulesCreateParameters;
/**
 * @deprecated Use ThermostatsSchedulesCreateRequest instead.
 */
type ThermostatsSchedulesCreateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/schedules/create'>>>;
type ThermostatsSchedulesCreateRequest = SeamHttpRequest<ThermostatsSchedulesCreateResponse, 'thermostat_schedule'>;
interface ThermostatsSchedulesCreateOptions {
}
type ThermostatsSchedulesDeleteParameters = RouteRequestBody<'/thermostats/schedules/delete'>;
/**
 * @deprecated Use ThermostatsSchedulesDeleteParameters instead.
 */
type ThermostatsSchedulesDeleteParams = ThermostatsSchedulesDeleteParameters;
/**
 * @deprecated Use ThermostatsSchedulesDeleteRequest instead.
 */
type ThermostatsSchedulesDeleteResponse = SetNonNullable<Required<RouteResponse<'/thermostats/schedules/delete'>>>;
type ThermostatsSchedulesDeleteRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSchedulesDeleteOptions {
}
type ThermostatsSchedulesGetParameters = RouteRequestBody<'/thermostats/schedules/get'>;
/**
 * @deprecated Use ThermostatsSchedulesGetParameters instead.
 */
type ThermostatsSchedulesGetParams = ThermostatsSchedulesGetParameters;
/**
 * @deprecated Use ThermostatsSchedulesGetRequest instead.
 */
type ThermostatsSchedulesGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/schedules/get'>>>;
type ThermostatsSchedulesGetRequest = SeamHttpRequest<ThermostatsSchedulesGetResponse, 'thermostat_schedule'>;
interface ThermostatsSchedulesGetOptions {
}
type ThermostatsSchedulesListParameters = RouteRequestBody<'/thermostats/schedules/list'>;
/**
 * @deprecated Use ThermostatsSchedulesListParameters instead.
 */
type ThermostatsSchedulesListParams = ThermostatsSchedulesListParameters;
/**
 * @deprecated Use ThermostatsSchedulesListRequest instead.
 */
type ThermostatsSchedulesListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/schedules/list'>>>;
type ThermostatsSchedulesListRequest = SeamHttpRequest<ThermostatsSchedulesListResponse, 'thermostat_schedules'>;
interface ThermostatsSchedulesListOptions {
}
type ThermostatsSchedulesUpdateParameters = RouteRequestBody<'/thermostats/schedules/update'>;
/**
 * @deprecated Use ThermostatsSchedulesUpdateParameters instead.
 */
type ThermostatsSchedulesUpdateBody = ThermostatsSchedulesUpdateParameters;
/**
 * @deprecated Use ThermostatsSchedulesUpdateRequest instead.
 */
type ThermostatsSchedulesUpdateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/schedules/update'>>>;
type ThermostatsSchedulesUpdateRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSchedulesUpdateOptions {
}

declare class SeamHttpThermostatsSimulate {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostatsSimulate;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostatsSimulate;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostatsSimulate;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostatsSimulate>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpThermostatsSimulate;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpThermostatsSimulate;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    hvacModeAdjusted(parameters?: ThermostatsSimulateHvacModeAdjustedParameters, options?: ThermostatsSimulateHvacModeAdjustedOptions): ThermostatsSimulateHvacModeAdjustedRequest;
    temperatureReached(parameters?: ThermostatsSimulateTemperatureReachedParameters, options?: ThermostatsSimulateTemperatureReachedOptions): ThermostatsSimulateTemperatureReachedRequest;
}
type ThermostatsSimulateHvacModeAdjustedParameters = RouteRequestBody<'/thermostats/simulate/hvac_mode_adjusted'>;
/**
 * @deprecated Use ThermostatsSimulateHvacModeAdjustedParameters instead.
 */
type ThermostatsSimulateHvacModeAdjustedBody = ThermostatsSimulateHvacModeAdjustedParameters;
/**
 * @deprecated Use ThermostatsSimulateHvacModeAdjustedRequest instead.
 */
type ThermostatsSimulateHvacModeAdjustedResponse = SetNonNullable<Required<RouteResponse<'/thermostats/simulate/hvac_mode_adjusted'>>>;
type ThermostatsSimulateHvacModeAdjustedRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSimulateHvacModeAdjustedOptions {
}
type ThermostatsSimulateTemperatureReachedParameters = RouteRequestBody<'/thermostats/simulate/temperature_reached'>;
/**
 * @deprecated Use ThermostatsSimulateTemperatureReachedParameters instead.
 */
type ThermostatsSimulateTemperatureReachedBody = ThermostatsSimulateTemperatureReachedParameters;
/**
 * @deprecated Use ThermostatsSimulateTemperatureReachedRequest instead.
 */
type ThermostatsSimulateTemperatureReachedResponse = SetNonNullable<Required<RouteResponse<'/thermostats/simulate/temperature_reached'>>>;
type ThermostatsSimulateTemperatureReachedRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSimulateTemperatureReachedOptions {
}

declare class SeamHttpThermostats {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostats;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostats;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostats;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostats>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpThermostats;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpThermostats;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get dailyPrograms(): SeamHttpThermostatsDailyPrograms;
    get schedules(): SeamHttpThermostatsSchedules;
    get simulate(): SeamHttpThermostatsSimulate;
    activateClimatePreset(parameters?: ThermostatsActivateClimatePresetParameters, options?: ThermostatsActivateClimatePresetOptions): ThermostatsActivateClimatePresetRequest;
    cool(parameters?: ThermostatsCoolParameters, options?: ThermostatsCoolOptions): ThermostatsCoolRequest;
    createClimatePreset(parameters?: ThermostatsCreateClimatePresetParameters, options?: ThermostatsCreateClimatePresetOptions): ThermostatsCreateClimatePresetRequest;
    deleteClimatePreset(parameters?: ThermostatsDeleteClimatePresetParameters, options?: ThermostatsDeleteClimatePresetOptions): ThermostatsDeleteClimatePresetRequest;
    get(parameters?: ThermostatsGetParameters, options?: ThermostatsGetOptions): ThermostatsGetRequest;
    heat(parameters?: ThermostatsHeatParameters, options?: ThermostatsHeatOptions): ThermostatsHeatRequest;
    heatCool(parameters?: ThermostatsHeatCoolParameters, options?: ThermostatsHeatCoolOptions): ThermostatsHeatCoolRequest;
    list(parameters?: ThermostatsListParameters, options?: ThermostatsListOptions): ThermostatsListRequest;
    off(parameters?: ThermostatsOffParameters, options?: ThermostatsOffOptions): ThermostatsOffRequest;
    setFallbackClimatePreset(parameters?: ThermostatsSetFallbackClimatePresetParameters, options?: ThermostatsSetFallbackClimatePresetOptions): ThermostatsSetFallbackClimatePresetRequest;
    setFanMode(parameters?: ThermostatsSetFanModeParameters, options?: ThermostatsSetFanModeOptions): ThermostatsSetFanModeRequest;
    setHvacMode(parameters?: ThermostatsSetHvacModeParameters, options?: ThermostatsSetHvacModeOptions): ThermostatsSetHvacModeRequest;
    setTemperatureThreshold(parameters?: ThermostatsSetTemperatureThresholdParameters, options?: ThermostatsSetTemperatureThresholdOptions): ThermostatsSetTemperatureThresholdRequest;
    updateClimatePreset(parameters?: ThermostatsUpdateClimatePresetParameters, options?: ThermostatsUpdateClimatePresetOptions): ThermostatsUpdateClimatePresetRequest;
    updateWeeklyProgram(parameters?: ThermostatsUpdateWeeklyProgramParameters, options?: ThermostatsUpdateWeeklyProgramOptions): ThermostatsUpdateWeeklyProgramRequest;
}
type ThermostatsActivateClimatePresetParameters = RouteRequestBody<'/thermostats/activate_climate_preset'>;
/**
 * @deprecated Use ThermostatsActivateClimatePresetParameters instead.
 */
type ThermostatsActivateClimatePresetBody = ThermostatsActivateClimatePresetParameters;
/**
 * @deprecated Use ThermostatsActivateClimatePresetRequest instead.
 */
type ThermostatsActivateClimatePresetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/activate_climate_preset'>>>;
type ThermostatsActivateClimatePresetRequest = SeamHttpRequest<ThermostatsActivateClimatePresetResponse, 'action_attempt'>;
type ThermostatsActivateClimatePresetOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsCoolParameters = RouteRequestBody<'/thermostats/cool'>;
/**
 * @deprecated Use ThermostatsCoolParameters instead.
 */
type ThermostatsCoolBody = ThermostatsCoolParameters;
/**
 * @deprecated Use ThermostatsCoolRequest instead.
 */
type ThermostatsCoolResponse = SetNonNullable<Required<RouteResponse<'/thermostats/cool'>>>;
type ThermostatsCoolRequest = SeamHttpRequest<ThermostatsCoolResponse, 'action_attempt'>;
type ThermostatsCoolOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsCreateClimatePresetParameters = RouteRequestBody<'/thermostats/create_climate_preset'>;
/**
 * @deprecated Use ThermostatsCreateClimatePresetParameters instead.
 */
type ThermostatsCreateClimatePresetBody = ThermostatsCreateClimatePresetParameters;
/**
 * @deprecated Use ThermostatsCreateClimatePresetRequest instead.
 */
type ThermostatsCreateClimatePresetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/create_climate_preset'>>>;
type ThermostatsCreateClimatePresetRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsCreateClimatePresetOptions {
}
type ThermostatsDeleteClimatePresetParameters = RouteRequestBody<'/thermostats/delete_climate_preset'>;
/**
 * @deprecated Use ThermostatsDeleteClimatePresetParameters instead.
 */
type ThermostatsDeleteClimatePresetParams = ThermostatsDeleteClimatePresetParameters;
/**
 * @deprecated Use ThermostatsDeleteClimatePresetRequest instead.
 */
type ThermostatsDeleteClimatePresetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/delete_climate_preset'>>>;
type ThermostatsDeleteClimatePresetRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsDeleteClimatePresetOptions {
}
type ThermostatsGetParameters = RouteRequestBody<'/thermostats/get'>;
/**
 * @deprecated Use ThermostatsGetParameters instead.
 */
type ThermostatsGetParams = ThermostatsGetParameters;
/**
 * @deprecated Use ThermostatsGetRequest instead.
 */
type ThermostatsGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/get'>>>;
type ThermostatsGetRequest = SeamHttpRequest<ThermostatsGetResponse, 'thermostat'>;
interface ThermostatsGetOptions {
}
type ThermostatsHeatParameters = RouteRequestBody<'/thermostats/heat'>;
/**
 * @deprecated Use ThermostatsHeatParameters instead.
 */
type ThermostatsHeatBody = ThermostatsHeatParameters;
/**
 * @deprecated Use ThermostatsHeatRequest instead.
 */
type ThermostatsHeatResponse = SetNonNullable<Required<RouteResponse<'/thermostats/heat'>>>;
type ThermostatsHeatRequest = SeamHttpRequest<ThermostatsHeatResponse, 'action_attempt'>;
type ThermostatsHeatOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsHeatCoolParameters = RouteRequestBody<'/thermostats/heat_cool'>;
/**
 * @deprecated Use ThermostatsHeatCoolParameters instead.
 */
type ThermostatsHeatCoolBody = ThermostatsHeatCoolParameters;
/**
 * @deprecated Use ThermostatsHeatCoolRequest instead.
 */
type ThermostatsHeatCoolResponse = SetNonNullable<Required<RouteResponse<'/thermostats/heat_cool'>>>;
type ThermostatsHeatCoolRequest = SeamHttpRequest<ThermostatsHeatCoolResponse, 'action_attempt'>;
type ThermostatsHeatCoolOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsListParameters = RouteRequestBody<'/thermostats/list'>;
/**
 * @deprecated Use ThermostatsListParameters instead.
 */
type ThermostatsListParams = ThermostatsListParameters;
/**
 * @deprecated Use ThermostatsListRequest instead.
 */
type ThermostatsListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/list'>>>;
type ThermostatsListRequest = SeamHttpRequest<ThermostatsListResponse, 'devices'>;
interface ThermostatsListOptions {
}
type ThermostatsOffParameters = RouteRequestBody<'/thermostats/off'>;
/**
 * @deprecated Use ThermostatsOffParameters instead.
 */
type ThermostatsOffBody = ThermostatsOffParameters;
/**
 * @deprecated Use ThermostatsOffRequest instead.
 */
type ThermostatsOffResponse = SetNonNullable<Required<RouteResponse<'/thermostats/off'>>>;
type ThermostatsOffRequest = SeamHttpRequest<ThermostatsOffResponse, 'action_attempt'>;
type ThermostatsOffOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsSetFallbackClimatePresetParameters = RouteRequestBody<'/thermostats/set_fallback_climate_preset'>;
/**
 * @deprecated Use ThermostatsSetFallbackClimatePresetParameters instead.
 */
type ThermostatsSetFallbackClimatePresetBody = ThermostatsSetFallbackClimatePresetParameters;
/**
 * @deprecated Use ThermostatsSetFallbackClimatePresetRequest instead.
 */
type ThermostatsSetFallbackClimatePresetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/set_fallback_climate_preset'>>>;
type ThermostatsSetFallbackClimatePresetRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSetFallbackClimatePresetOptions {
}
type ThermostatsSetFanModeParameters = RouteRequestBody<'/thermostats/set_fan_mode'>;
/**
 * @deprecated Use ThermostatsSetFanModeParameters instead.
 */
type ThermostatsSetFanModeBody = ThermostatsSetFanModeParameters;
/**
 * @deprecated Use ThermostatsSetFanModeRequest instead.
 */
type ThermostatsSetFanModeResponse = SetNonNullable<Required<RouteResponse<'/thermostats/set_fan_mode'>>>;
type ThermostatsSetFanModeRequest = SeamHttpRequest<ThermostatsSetFanModeResponse, 'action_attempt'>;
type ThermostatsSetFanModeOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsSetHvacModeParameters = RouteRequestBody<'/thermostats/set_hvac_mode'>;
/**
 * @deprecated Use ThermostatsSetHvacModeParameters instead.
 */
type ThermostatsSetHvacModeBody = ThermostatsSetHvacModeParameters;
/**
 * @deprecated Use ThermostatsSetHvacModeRequest instead.
 */
type ThermostatsSetHvacModeResponse = SetNonNullable<Required<RouteResponse<'/thermostats/set_hvac_mode'>>>;
type ThermostatsSetHvacModeRequest = SeamHttpRequest<ThermostatsSetHvacModeResponse, 'action_attempt'>;
type ThermostatsSetHvacModeOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type ThermostatsSetTemperatureThresholdParameters = RouteRequestBody<'/thermostats/set_temperature_threshold'>;
/**
 * @deprecated Use ThermostatsSetTemperatureThresholdParameters instead.
 */
type ThermostatsSetTemperatureThresholdBody = ThermostatsSetTemperatureThresholdParameters;
/**
 * @deprecated Use ThermostatsSetTemperatureThresholdRequest instead.
 */
type ThermostatsSetTemperatureThresholdResponse = SetNonNullable<Required<RouteResponse<'/thermostats/set_temperature_threshold'>>>;
type ThermostatsSetTemperatureThresholdRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsSetTemperatureThresholdOptions {
}
type ThermostatsUpdateClimatePresetParameters = RouteRequestBody<'/thermostats/update_climate_preset'>;
/**
 * @deprecated Use ThermostatsUpdateClimatePresetParameters instead.
 */
type ThermostatsUpdateClimatePresetBody = ThermostatsUpdateClimatePresetParameters;
/**
 * @deprecated Use ThermostatsUpdateClimatePresetRequest instead.
 */
type ThermostatsUpdateClimatePresetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/update_climate_preset'>>>;
type ThermostatsUpdateClimatePresetRequest = SeamHttpRequest<void, undefined>;
interface ThermostatsUpdateClimatePresetOptions {
}
type ThermostatsUpdateWeeklyProgramParameters = RouteRequestBody<'/thermostats/update_weekly_program'>;
/**
 * @deprecated Use ThermostatsUpdateWeeklyProgramParameters instead.
 */
type ThermostatsUpdateWeeklyProgramBody = ThermostatsUpdateWeeklyProgramParameters;
/**
 * @deprecated Use ThermostatsUpdateWeeklyProgramRequest instead.
 */
type ThermostatsUpdateWeeklyProgramResponse = SetNonNullable<Required<RouteResponse<'/thermostats/update_weekly_program'>>>;
type ThermostatsUpdateWeeklyProgramRequest = SeamHttpRequest<ThermostatsUpdateWeeklyProgramResponse, 'action_attempt'>;
type ThermostatsUpdateWeeklyProgramOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;

declare class SeamHttpUnstablePartnerBuildingBlocks {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpUnstablePartnerBuildingBlocks;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpUnstablePartnerBuildingBlocks;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpUnstablePartnerBuildingBlocks;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpUnstablePartnerBuildingBlocks>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpUnstablePartnerBuildingBlocks;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpUnstablePartnerBuildingBlocks;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    connectAccounts(parameters?: UnstablePartnerBuildingBlocksConnectAccountsParameters, options?: UnstablePartnerBuildingBlocksConnectAccountsOptions): UnstablePartnerBuildingBlocksConnectAccountsRequest;
    generateMagicLink(parameters?: UnstablePartnerBuildingBlocksGenerateMagicLinkParameters, options?: UnstablePartnerBuildingBlocksGenerateMagicLinkOptions): UnstablePartnerBuildingBlocksGenerateMagicLinkRequest;
    manageDevices(parameters?: UnstablePartnerBuildingBlocksManageDevicesParameters, options?: UnstablePartnerBuildingBlocksManageDevicesOptions): UnstablePartnerBuildingBlocksManageDevicesRequest;
    organizeSpaces(parameters?: UnstablePartnerBuildingBlocksOrganizeSpacesParameters, options?: UnstablePartnerBuildingBlocksOrganizeSpacesOptions): UnstablePartnerBuildingBlocksOrganizeSpacesRequest;
}
type UnstablePartnerBuildingBlocksConnectAccountsParameters = RouteRequestBody<'/unstable_partner/building_blocks/connect_accounts'>;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksConnectAccountsParameters instead.
 */
type UnstablePartnerBuildingBlocksConnectAccountsBody = UnstablePartnerBuildingBlocksConnectAccountsParameters;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksConnectAccountsRequest instead.
 */
type UnstablePartnerBuildingBlocksConnectAccountsResponse = SetNonNullable<Required<RouteResponse<'/unstable_partner/building_blocks/connect_accounts'>>>;
type UnstablePartnerBuildingBlocksConnectAccountsRequest = SeamHttpRequest<UnstablePartnerBuildingBlocksConnectAccountsResponse, 'magic_link'>;
interface UnstablePartnerBuildingBlocksConnectAccountsOptions {
}
type UnstablePartnerBuildingBlocksGenerateMagicLinkParameters = RouteRequestBody<'/unstable_partner/building_blocks/generate_magic_link'>;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksGenerateMagicLinkParameters instead.
 */
type UnstablePartnerBuildingBlocksGenerateMagicLinkParams = UnstablePartnerBuildingBlocksGenerateMagicLinkParameters;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksGenerateMagicLinkRequest instead.
 */
type UnstablePartnerBuildingBlocksGenerateMagicLinkResponse = SetNonNullable<Required<RouteResponse<'/unstable_partner/building_blocks/generate_magic_link'>>>;
type UnstablePartnerBuildingBlocksGenerateMagicLinkRequest = SeamHttpRequest<UnstablePartnerBuildingBlocksGenerateMagicLinkResponse, 'magic_link'>;
interface UnstablePartnerBuildingBlocksGenerateMagicLinkOptions {
}
type UnstablePartnerBuildingBlocksManageDevicesParameters = RouteRequestBody<'/unstable_partner/building_blocks/manage_devices'>;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksManageDevicesParameters instead.
 */
type UnstablePartnerBuildingBlocksManageDevicesBody = UnstablePartnerBuildingBlocksManageDevicesParameters;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksManageDevicesRequest instead.
 */
type UnstablePartnerBuildingBlocksManageDevicesResponse = SetNonNullable<Required<RouteResponse<'/unstable_partner/building_blocks/manage_devices'>>>;
type UnstablePartnerBuildingBlocksManageDevicesRequest = SeamHttpRequest<UnstablePartnerBuildingBlocksManageDevicesResponse, 'magic_link'>;
interface UnstablePartnerBuildingBlocksManageDevicesOptions {
}
type UnstablePartnerBuildingBlocksOrganizeSpacesParameters = RouteRequestBody<'/unstable_partner/building_blocks/organize_spaces'>;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksOrganizeSpacesParameters instead.
 */
type UnstablePartnerBuildingBlocksOrganizeSpacesBody = UnstablePartnerBuildingBlocksOrganizeSpacesParameters;
/**
 * @deprecated Use UnstablePartnerBuildingBlocksOrganizeSpacesRequest instead.
 */
type UnstablePartnerBuildingBlocksOrganizeSpacesResponse = SetNonNullable<Required<RouteResponse<'/unstable_partner/building_blocks/organize_spaces'>>>;
type UnstablePartnerBuildingBlocksOrganizeSpacesRequest = SeamHttpRequest<UnstablePartnerBuildingBlocksOrganizeSpacesResponse, 'magic_link'>;
interface UnstablePartnerBuildingBlocksOrganizeSpacesOptions {
}

declare class SeamHttpUnstablePartner {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpUnstablePartner;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpUnstablePartner;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpUnstablePartner;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpUnstablePartner>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpUnstablePartner;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpUnstablePartner;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get buildingBlocks(): SeamHttpUnstablePartnerBuildingBlocks;
}

declare class SeamHttpUserIdentitiesEnrollmentAutomations {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpUserIdentitiesEnrollmentAutomations;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpUserIdentitiesEnrollmentAutomations;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpUserIdentitiesEnrollmentAutomations;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpUserIdentitiesEnrollmentAutomations>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpUserIdentitiesEnrollmentAutomations;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpUserIdentitiesEnrollmentAutomations;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    delete(parameters?: UserIdentitiesEnrollmentAutomationsDeleteParameters, options?: UserIdentitiesEnrollmentAutomationsDeleteOptions): UserIdentitiesEnrollmentAutomationsDeleteRequest;
    get(parameters?: UserIdentitiesEnrollmentAutomationsGetParameters, options?: UserIdentitiesEnrollmentAutomationsGetOptions): UserIdentitiesEnrollmentAutomationsGetRequest;
    launch(parameters?: UserIdentitiesEnrollmentAutomationsLaunchParameters, options?: UserIdentitiesEnrollmentAutomationsLaunchOptions): UserIdentitiesEnrollmentAutomationsLaunchRequest;
    list(parameters?: UserIdentitiesEnrollmentAutomationsListParameters, options?: UserIdentitiesEnrollmentAutomationsListOptions): UserIdentitiesEnrollmentAutomationsListRequest;
}
type UserIdentitiesEnrollmentAutomationsDeleteParameters = RouteRequestBody<'/user_identities/enrollment_automations/delete'>;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsDeleteParameters instead.
 */
type UserIdentitiesEnrollmentAutomationsDeleteParams = UserIdentitiesEnrollmentAutomationsDeleteParameters;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsDeleteRequest instead.
 */
type UserIdentitiesEnrollmentAutomationsDeleteResponse = SetNonNullable<Required<RouteResponse<'/user_identities/enrollment_automations/delete'>>>;
type UserIdentitiesEnrollmentAutomationsDeleteRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesEnrollmentAutomationsDeleteOptions {
}
type UserIdentitiesEnrollmentAutomationsGetParameters = RouteRequestBody<'/user_identities/enrollment_automations/get'>;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsGetParameters instead.
 */
type UserIdentitiesEnrollmentAutomationsGetParams = UserIdentitiesEnrollmentAutomationsGetParameters;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsGetRequest instead.
 */
type UserIdentitiesEnrollmentAutomationsGetResponse = SetNonNullable<Required<RouteResponse<'/user_identities/enrollment_automations/get'>>>;
type UserIdentitiesEnrollmentAutomationsGetRequest = SeamHttpRequest<UserIdentitiesEnrollmentAutomationsGetResponse, 'enrollment_automation'>;
interface UserIdentitiesEnrollmentAutomationsGetOptions {
}
type UserIdentitiesEnrollmentAutomationsLaunchParameters = RouteRequestBody<'/user_identities/enrollment_automations/launch'>;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsLaunchParameters instead.
 */
type UserIdentitiesEnrollmentAutomationsLaunchBody = UserIdentitiesEnrollmentAutomationsLaunchParameters;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsLaunchRequest instead.
 */
type UserIdentitiesEnrollmentAutomationsLaunchResponse = SetNonNullable<Required<RouteResponse<'/user_identities/enrollment_automations/launch'>>>;
type UserIdentitiesEnrollmentAutomationsLaunchRequest = SeamHttpRequest<UserIdentitiesEnrollmentAutomationsLaunchResponse, 'enrollment_automation'>;
interface UserIdentitiesEnrollmentAutomationsLaunchOptions {
}
type UserIdentitiesEnrollmentAutomationsListParameters = RouteRequestBody<'/user_identities/enrollment_automations/list'>;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsListParameters instead.
 */
type UserIdentitiesEnrollmentAutomationsListParams = UserIdentitiesEnrollmentAutomationsListParameters;
/**
 * @deprecated Use UserIdentitiesEnrollmentAutomationsListRequest instead.
 */
type UserIdentitiesEnrollmentAutomationsListResponse = SetNonNullable<Required<RouteResponse<'/user_identities/enrollment_automations/list'>>>;
type UserIdentitiesEnrollmentAutomationsListRequest = SeamHttpRequest<UserIdentitiesEnrollmentAutomationsListResponse, 'enrollment_automations'>;
interface UserIdentitiesEnrollmentAutomationsListOptions {
}

declare class SeamHttpUserIdentitiesUnmanaged {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpUserIdentitiesUnmanaged;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpUserIdentitiesUnmanaged;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpUserIdentitiesUnmanaged;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpUserIdentitiesUnmanaged>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpUserIdentitiesUnmanaged;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpUserIdentitiesUnmanaged;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get(parameters?: UserIdentitiesUnmanagedGetParameters, options?: UserIdentitiesUnmanagedGetOptions): UserIdentitiesUnmanagedGetRequest;
    list(parameters?: UserIdentitiesUnmanagedListParameters, options?: UserIdentitiesUnmanagedListOptions): UserIdentitiesUnmanagedListRequest;
    update(parameters?: UserIdentitiesUnmanagedUpdateParameters, options?: UserIdentitiesUnmanagedUpdateOptions): UserIdentitiesUnmanagedUpdateRequest;
}
type UserIdentitiesUnmanagedGetParameters = RouteRequestBody<'/user_identities/unmanaged/get'>;
/**
 * @deprecated Use UserIdentitiesUnmanagedGetParameters instead.
 */
type UserIdentitiesUnmanagedGetParams = UserIdentitiesUnmanagedGetParameters;
/**
 * @deprecated Use UserIdentitiesUnmanagedGetRequest instead.
 */
type UserIdentitiesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/user_identities/unmanaged/get'>>>;
type UserIdentitiesUnmanagedGetRequest = SeamHttpRequest<UserIdentitiesUnmanagedGetResponse, 'user_identity'>;
interface UserIdentitiesUnmanagedGetOptions {
}
type UserIdentitiesUnmanagedListParameters = RouteRequestBody<'/user_identities/unmanaged/list'>;
/**
 * @deprecated Use UserIdentitiesUnmanagedListParameters instead.
 */
type UserIdentitiesUnmanagedListParams = UserIdentitiesUnmanagedListParameters;
/**
 * @deprecated Use UserIdentitiesUnmanagedListRequest instead.
 */
type UserIdentitiesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/user_identities/unmanaged/list'>>>;
type UserIdentitiesUnmanagedListRequest = SeamHttpRequest<UserIdentitiesUnmanagedListResponse, 'user_identities'>;
interface UserIdentitiesUnmanagedListOptions {
}
type UserIdentitiesUnmanagedUpdateParameters = RouteRequestBody<'/user_identities/unmanaged/update'>;
/**
 * @deprecated Use UserIdentitiesUnmanagedUpdateParameters instead.
 */
type UserIdentitiesUnmanagedUpdateBody = UserIdentitiesUnmanagedUpdateParameters;
/**
 * @deprecated Use UserIdentitiesUnmanagedUpdateRequest instead.
 */
type UserIdentitiesUnmanagedUpdateResponse = SetNonNullable<Required<RouteResponse<'/user_identities/unmanaged/update'>>>;
type UserIdentitiesUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesUnmanagedUpdateOptions {
}

declare class SeamHttpUserIdentities {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpUserIdentities;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpUserIdentities;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpUserIdentities;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpUserIdentities>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpUserIdentities;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpUserIdentities;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get enrollmentAutomations(): SeamHttpUserIdentitiesEnrollmentAutomations;
    get unmanaged(): SeamHttpUserIdentitiesUnmanaged;
    addAcsUser(parameters?: UserIdentitiesAddAcsUserParameters, options?: UserIdentitiesAddAcsUserOptions): UserIdentitiesAddAcsUserRequest;
    create(parameters?: UserIdentitiesCreateParameters, options?: UserIdentitiesCreateOptions): UserIdentitiesCreateRequest;
    delete(parameters?: UserIdentitiesDeleteParameters, options?: UserIdentitiesDeleteOptions): UserIdentitiesDeleteRequest;
    generateInstantKey(parameters?: UserIdentitiesGenerateInstantKeyParameters, options?: UserIdentitiesGenerateInstantKeyOptions): UserIdentitiesGenerateInstantKeyRequest;
    get(parameters?: UserIdentitiesGetParameters, options?: UserIdentitiesGetOptions): UserIdentitiesGetRequest;
    grantAccessToDevice(parameters?: UserIdentitiesGrantAccessToDeviceParameters, options?: UserIdentitiesGrantAccessToDeviceOptions): UserIdentitiesGrantAccessToDeviceRequest;
    list(parameters?: UserIdentitiesListParameters, options?: UserIdentitiesListOptions): UserIdentitiesListRequest;
    listAccessibleDevices(parameters?: UserIdentitiesListAccessibleDevicesParameters, options?: UserIdentitiesListAccessibleDevicesOptions): UserIdentitiesListAccessibleDevicesRequest;
    listAccessibleEntrances(parameters?: UserIdentitiesListAccessibleEntrancesParameters, options?: UserIdentitiesListAccessibleEntrancesOptions): UserIdentitiesListAccessibleEntrancesRequest;
    listAcsSystems(parameters?: UserIdentitiesListAcsSystemsParameters, options?: UserIdentitiesListAcsSystemsOptions): UserIdentitiesListAcsSystemsRequest;
    listAcsUsers(parameters?: UserIdentitiesListAcsUsersParameters, options?: UserIdentitiesListAcsUsersOptions): UserIdentitiesListAcsUsersRequest;
    removeAcsUser(parameters?: UserIdentitiesRemoveAcsUserParameters, options?: UserIdentitiesRemoveAcsUserOptions): UserIdentitiesRemoveAcsUserRequest;
    revokeAccessToDevice(parameters?: UserIdentitiesRevokeAccessToDeviceParameters, options?: UserIdentitiesRevokeAccessToDeviceOptions): UserIdentitiesRevokeAccessToDeviceRequest;
    update(parameters?: UserIdentitiesUpdateParameters, options?: UserIdentitiesUpdateOptions): UserIdentitiesUpdateRequest;
}
type UserIdentitiesAddAcsUserParameters = RouteRequestBody<'/user_identities/add_acs_user'>;
/**
 * @deprecated Use UserIdentitiesAddAcsUserParameters instead.
 */
type UserIdentitiesAddAcsUserBody = UserIdentitiesAddAcsUserParameters;
/**
 * @deprecated Use UserIdentitiesAddAcsUserRequest instead.
 */
type UserIdentitiesAddAcsUserResponse = SetNonNullable<Required<RouteResponse<'/user_identities/add_acs_user'>>>;
type UserIdentitiesAddAcsUserRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesAddAcsUserOptions {
}
type UserIdentitiesCreateParameters = RouteRequestBody<'/user_identities/create'>;
/**
 * @deprecated Use UserIdentitiesCreateParameters instead.
 */
type UserIdentitiesCreateBody = UserIdentitiesCreateParameters;
/**
 * @deprecated Use UserIdentitiesCreateRequest instead.
 */
type UserIdentitiesCreateResponse = SetNonNullable<Required<RouteResponse<'/user_identities/create'>>>;
type UserIdentitiesCreateRequest = SeamHttpRequest<UserIdentitiesCreateResponse, 'user_identity'>;
interface UserIdentitiesCreateOptions {
}
type UserIdentitiesDeleteParameters = RouteRequestBody<'/user_identities/delete'>;
/**
 * @deprecated Use UserIdentitiesDeleteParameters instead.
 */
type UserIdentitiesDeleteParams = UserIdentitiesDeleteParameters;
/**
 * @deprecated Use UserIdentitiesDeleteRequest instead.
 */
type UserIdentitiesDeleteResponse = SetNonNullable<Required<RouteResponse<'/user_identities/delete'>>>;
type UserIdentitiesDeleteRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesDeleteOptions {
}
type UserIdentitiesGenerateInstantKeyParameters = RouteRequestBody<'/user_identities/generate_instant_key'>;
/**
 * @deprecated Use UserIdentitiesGenerateInstantKeyParameters instead.
 */
type UserIdentitiesGenerateInstantKeyBody = UserIdentitiesGenerateInstantKeyParameters;
/**
 * @deprecated Use UserIdentitiesGenerateInstantKeyRequest instead.
 */
type UserIdentitiesGenerateInstantKeyResponse = SetNonNullable<Required<RouteResponse<'/user_identities/generate_instant_key'>>>;
type UserIdentitiesGenerateInstantKeyRequest = SeamHttpRequest<UserIdentitiesGenerateInstantKeyResponse, 'instant_key'>;
interface UserIdentitiesGenerateInstantKeyOptions {
}
type UserIdentitiesGetParameters = RouteRequestParams<'/user_identities/get'>;
/**
 * @deprecated Use UserIdentitiesGetParameters instead.
 */
type UserIdentitiesGetParams = UserIdentitiesGetParameters;
/**
 * @deprecated Use UserIdentitiesGetRequest instead.
 */
type UserIdentitiesGetResponse = SetNonNullable<Required<RouteResponse<'/user_identities/get'>>>;
type UserIdentitiesGetRequest = SeamHttpRequest<UserIdentitiesGetResponse, 'user_identity'>;
interface UserIdentitiesGetOptions {
}
type UserIdentitiesGrantAccessToDeviceParameters = RouteRequestBody<'/user_identities/grant_access_to_device'>;
/**
 * @deprecated Use UserIdentitiesGrantAccessToDeviceParameters instead.
 */
type UserIdentitiesGrantAccessToDeviceBody = UserIdentitiesGrantAccessToDeviceParameters;
/**
 * @deprecated Use UserIdentitiesGrantAccessToDeviceRequest instead.
 */
type UserIdentitiesGrantAccessToDeviceResponse = SetNonNullable<Required<RouteResponse<'/user_identities/grant_access_to_device'>>>;
type UserIdentitiesGrantAccessToDeviceRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesGrantAccessToDeviceOptions {
}
type UserIdentitiesListParameters = RouteRequestBody<'/user_identities/list'>;
/**
 * @deprecated Use UserIdentitiesListParameters instead.
 */
type UserIdentitiesListParams = UserIdentitiesListParameters;
/**
 * @deprecated Use UserIdentitiesListRequest instead.
 */
type UserIdentitiesListResponse = SetNonNullable<Required<RouteResponse<'/user_identities/list'>>>;
type UserIdentitiesListRequest = SeamHttpRequest<UserIdentitiesListResponse, 'user_identities'>;
interface UserIdentitiesListOptions {
}
type UserIdentitiesListAccessibleDevicesParameters = RouteRequestBody<'/user_identities/list_accessible_devices'>;
/**
 * @deprecated Use UserIdentitiesListAccessibleDevicesParameters instead.
 */
type UserIdentitiesListAccessibleDevicesParams = UserIdentitiesListAccessibleDevicesParameters;
/**
 * @deprecated Use UserIdentitiesListAccessibleDevicesRequest instead.
 */
type UserIdentitiesListAccessibleDevicesResponse = SetNonNullable<Required<RouteResponse<'/user_identities/list_accessible_devices'>>>;
type UserIdentitiesListAccessibleDevicesRequest = SeamHttpRequest<UserIdentitiesListAccessibleDevicesResponse, 'devices'>;
interface UserIdentitiesListAccessibleDevicesOptions {
}
type UserIdentitiesListAccessibleEntrancesParameters = RouteRequestBody<'/user_identities/list_accessible_entrances'>;
/**
 * @deprecated Use UserIdentitiesListAccessibleEntrancesParameters instead.
 */
type UserIdentitiesListAccessibleEntrancesParams = UserIdentitiesListAccessibleEntrancesParameters;
/**
 * @deprecated Use UserIdentitiesListAccessibleEntrancesRequest instead.
 */
type UserIdentitiesListAccessibleEntrancesResponse = SetNonNullable<Required<RouteResponse<'/user_identities/list_accessible_entrances'>>>;
type UserIdentitiesListAccessibleEntrancesRequest = SeamHttpRequest<UserIdentitiesListAccessibleEntrancesResponse, 'acs_entrances'>;
interface UserIdentitiesListAccessibleEntrancesOptions {
}
type UserIdentitiesListAcsSystemsParameters = RouteRequestBody<'/user_identities/list_acs_systems'>;
/**
 * @deprecated Use UserIdentitiesListAcsSystemsParameters instead.
 */
type UserIdentitiesListAcsSystemsParams = UserIdentitiesListAcsSystemsParameters;
/**
 * @deprecated Use UserIdentitiesListAcsSystemsRequest instead.
 */
type UserIdentitiesListAcsSystemsResponse = SetNonNullable<Required<RouteResponse<'/user_identities/list_acs_systems'>>>;
type UserIdentitiesListAcsSystemsRequest = SeamHttpRequest<UserIdentitiesListAcsSystemsResponse, 'acs_systems'>;
interface UserIdentitiesListAcsSystemsOptions {
}
type UserIdentitiesListAcsUsersParameters = RouteRequestBody<'/user_identities/list_acs_users'>;
/**
 * @deprecated Use UserIdentitiesListAcsUsersParameters instead.
 */
type UserIdentitiesListAcsUsersParams = UserIdentitiesListAcsUsersParameters;
/**
 * @deprecated Use UserIdentitiesListAcsUsersRequest instead.
 */
type UserIdentitiesListAcsUsersResponse = SetNonNullable<Required<RouteResponse<'/user_identities/list_acs_users'>>>;
type UserIdentitiesListAcsUsersRequest = SeamHttpRequest<UserIdentitiesListAcsUsersResponse, 'acs_users'>;
interface UserIdentitiesListAcsUsersOptions {
}
type UserIdentitiesRemoveAcsUserParameters = RouteRequestBody<'/user_identities/remove_acs_user'>;
/**
 * @deprecated Use UserIdentitiesRemoveAcsUserParameters instead.
 */
type UserIdentitiesRemoveAcsUserParams = UserIdentitiesRemoveAcsUserParameters;
/**
 * @deprecated Use UserIdentitiesRemoveAcsUserRequest instead.
 */
type UserIdentitiesRemoveAcsUserResponse = SetNonNullable<Required<RouteResponse<'/user_identities/remove_acs_user'>>>;
type UserIdentitiesRemoveAcsUserRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesRemoveAcsUserOptions {
}
type UserIdentitiesRevokeAccessToDeviceParameters = RouteRequestBody<'/user_identities/revoke_access_to_device'>;
/**
 * @deprecated Use UserIdentitiesRevokeAccessToDeviceParameters instead.
 */
type UserIdentitiesRevokeAccessToDeviceParams = UserIdentitiesRevokeAccessToDeviceParameters;
/**
 * @deprecated Use UserIdentitiesRevokeAccessToDeviceRequest instead.
 */
type UserIdentitiesRevokeAccessToDeviceResponse = SetNonNullable<Required<RouteResponse<'/user_identities/revoke_access_to_device'>>>;
type UserIdentitiesRevokeAccessToDeviceRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesRevokeAccessToDeviceOptions {
}
type UserIdentitiesUpdateParameters = RouteRequestBody<'/user_identities/update'>;
/**
 * @deprecated Use UserIdentitiesUpdateParameters instead.
 */
type UserIdentitiesUpdateBody = UserIdentitiesUpdateParameters;
/**
 * @deprecated Use UserIdentitiesUpdateRequest instead.
 */
type UserIdentitiesUpdateResponse = SetNonNullable<Required<RouteResponse<'/user_identities/update'>>>;
type UserIdentitiesUpdateRequest = SeamHttpRequest<void, undefined>;
interface UserIdentitiesUpdateOptions {
}

declare class SeamHttpWebhooks {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpWebhooks;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpWebhooks;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpWebhooks;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpWebhooks>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpWebhooks;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpWebhooks;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: WebhooksCreateParameters, options?: WebhooksCreateOptions): WebhooksCreateRequest;
    delete(parameters?: WebhooksDeleteParameters, options?: WebhooksDeleteOptions): WebhooksDeleteRequest;
    get(parameters?: WebhooksGetParameters, options?: WebhooksGetOptions): WebhooksGetRequest;
    list(parameters?: WebhooksListParameters, options?: WebhooksListOptions): WebhooksListRequest;
    update(parameters?: WebhooksUpdateParameters, options?: WebhooksUpdateOptions): WebhooksUpdateRequest;
}
type WebhooksCreateParameters = RouteRequestBody<'/webhooks/create'>;
/**
 * @deprecated Use WebhooksCreateParameters instead.
 */
type WebhooksCreateBody = WebhooksCreateParameters;
/**
 * @deprecated Use WebhooksCreateRequest instead.
 */
type WebhooksCreateResponse = SetNonNullable<Required<RouteResponse<'/webhooks/create'>>>;
type WebhooksCreateRequest = SeamHttpRequest<WebhooksCreateResponse, 'webhook'>;
interface WebhooksCreateOptions {
}
type WebhooksDeleteParameters = RouteRequestBody<'/webhooks/delete'>;
/**
 * @deprecated Use WebhooksDeleteParameters instead.
 */
type WebhooksDeleteParams = WebhooksDeleteParameters;
/**
 * @deprecated Use WebhooksDeleteRequest instead.
 */
type WebhooksDeleteResponse = SetNonNullable<Required<RouteResponse<'/webhooks/delete'>>>;
type WebhooksDeleteRequest = SeamHttpRequest<void, undefined>;
interface WebhooksDeleteOptions {
}
type WebhooksGetParameters = RouteRequestBody<'/webhooks/get'>;
/**
 * @deprecated Use WebhooksGetParameters instead.
 */
type WebhooksGetParams = WebhooksGetParameters;
/**
 * @deprecated Use WebhooksGetRequest instead.
 */
type WebhooksGetResponse = SetNonNullable<Required<RouteResponse<'/webhooks/get'>>>;
type WebhooksGetRequest = SeamHttpRequest<WebhooksGetResponse, 'webhook'>;
interface WebhooksGetOptions {
}
type WebhooksListParameters = RouteRequestParams<'/webhooks/list'>;
/**
 * @deprecated Use WebhooksListParameters instead.
 */
type WebhooksListParams = WebhooksListParameters;
/**
 * @deprecated Use WebhooksListRequest instead.
 */
type WebhooksListResponse = SetNonNullable<Required<RouteResponse<'/webhooks/list'>>>;
type WebhooksListRequest = SeamHttpRequest<WebhooksListResponse, 'webhooks'>;
interface WebhooksListOptions {
}
type WebhooksUpdateParameters = RouteRequestBody<'/webhooks/update'>;
/**
 * @deprecated Use WebhooksUpdateParameters instead.
 */
type WebhooksUpdateBody = WebhooksUpdateParameters;
/**
 * @deprecated Use WebhooksUpdateRequest instead.
 */
type WebhooksUpdateResponse = SetNonNullable<Required<RouteResponse<'/webhooks/update'>>>;
type WebhooksUpdateRequest = SeamHttpRequest<void, undefined>;
interface WebhooksUpdateOptions {
}

declare class SeamHttpWorkspacesCustomizationProfiles {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpWorkspacesCustomizationProfiles;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpWorkspacesCustomizationProfiles;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpWorkspacesCustomizationProfiles;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpWorkspacesCustomizationProfiles>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpWorkspacesCustomizationProfiles;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpWorkspacesCustomizationProfiles;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    create(parameters?: WorkspacesCustomizationProfilesCreateParameters, options?: WorkspacesCustomizationProfilesCreateOptions): WorkspacesCustomizationProfilesCreateRequest;
    get(parameters?: WorkspacesCustomizationProfilesGetParameters, options?: WorkspacesCustomizationProfilesGetOptions): WorkspacesCustomizationProfilesGetRequest;
    list(parameters?: WorkspacesCustomizationProfilesListParameters, options?: WorkspacesCustomizationProfilesListOptions): WorkspacesCustomizationProfilesListRequest;
    update(parameters?: WorkspacesCustomizationProfilesUpdateParameters, options?: WorkspacesCustomizationProfilesUpdateOptions): WorkspacesCustomizationProfilesUpdateRequest;
    uploadImages(parameters?: WorkspacesCustomizationProfilesUploadImagesParameters, options?: WorkspacesCustomizationProfilesUploadImagesOptions): WorkspacesCustomizationProfilesUploadImagesRequest;
}
type WorkspacesCustomizationProfilesCreateParameters = RouteRequestBody<'/workspaces/customization_profiles/create'>;
/**
 * @deprecated Use WorkspacesCustomizationProfilesCreateParameters instead.
 */
type WorkspacesCustomizationProfilesCreateBody = WorkspacesCustomizationProfilesCreateParameters;
/**
 * @deprecated Use WorkspacesCustomizationProfilesCreateRequest instead.
 */
type WorkspacesCustomizationProfilesCreateResponse = SetNonNullable<Required<RouteResponse<'/workspaces/customization_profiles/create'>>>;
type WorkspacesCustomizationProfilesCreateRequest = SeamHttpRequest<WorkspacesCustomizationProfilesCreateResponse, 'customization_profile'>;
interface WorkspacesCustomizationProfilesCreateOptions {
}
type WorkspacesCustomizationProfilesGetParameters = RouteRequestBody<'/workspaces/customization_profiles/get'>;
/**
 * @deprecated Use WorkspacesCustomizationProfilesGetParameters instead.
 */
type WorkspacesCustomizationProfilesGetParams = WorkspacesCustomizationProfilesGetParameters;
/**
 * @deprecated Use WorkspacesCustomizationProfilesGetRequest instead.
 */
type WorkspacesCustomizationProfilesGetResponse = SetNonNullable<Required<RouteResponse<'/workspaces/customization_profiles/get'>>>;
type WorkspacesCustomizationProfilesGetRequest = SeamHttpRequest<WorkspacesCustomizationProfilesGetResponse, 'customization_profile'>;
interface WorkspacesCustomizationProfilesGetOptions {
}
type WorkspacesCustomizationProfilesListParameters = RouteRequestBody<'/workspaces/customization_profiles/list'>;
/**
 * @deprecated Use WorkspacesCustomizationProfilesListParameters instead.
 */
type WorkspacesCustomizationProfilesListParams = WorkspacesCustomizationProfilesListParameters;
/**
 * @deprecated Use WorkspacesCustomizationProfilesListRequest instead.
 */
type WorkspacesCustomizationProfilesListResponse = SetNonNullable<Required<RouteResponse<'/workspaces/customization_profiles/list'>>>;
type WorkspacesCustomizationProfilesListRequest = SeamHttpRequest<WorkspacesCustomizationProfilesListResponse, 'customization_profiles'>;
interface WorkspacesCustomizationProfilesListOptions {
}
type WorkspacesCustomizationProfilesUpdateParameters = RouteRequestBody<'/workspaces/customization_profiles/update'>;
/**
 * @deprecated Use WorkspacesCustomizationProfilesUpdateParameters instead.
 */
type WorkspacesCustomizationProfilesUpdateBody = WorkspacesCustomizationProfilesUpdateParameters;
/**
 * @deprecated Use WorkspacesCustomizationProfilesUpdateRequest instead.
 */
type WorkspacesCustomizationProfilesUpdateResponse = SetNonNullable<Required<RouteResponse<'/workspaces/customization_profiles/update'>>>;
type WorkspacesCustomizationProfilesUpdateRequest = SeamHttpRequest<void, undefined>;
interface WorkspacesCustomizationProfilesUpdateOptions {
}
type WorkspacesCustomizationProfilesUploadImagesParameters = RouteRequestBody<'/workspaces/customization_profiles/upload_images'>;
/**
 * @deprecated Use WorkspacesCustomizationProfilesUploadImagesParameters instead.
 */
type WorkspacesCustomizationProfilesUploadImagesBody = WorkspacesCustomizationProfilesUploadImagesParameters;
/**
 * @deprecated Use WorkspacesCustomizationProfilesUploadImagesRequest instead.
 */
type WorkspacesCustomizationProfilesUploadImagesResponse = SetNonNullable<Required<RouteResponse<'/workspaces/customization_profiles/upload_images'>>>;
type WorkspacesCustomizationProfilesUploadImagesRequest = SeamHttpRequest<void, undefined>;
interface WorkspacesCustomizationProfilesUploadImagesOptions {
}

declare class SeamHttpWorkspaces {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpWorkspaces;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpWorkspaces;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpWorkspaces;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpWorkspaces>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpWorkspaces;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpWorkspaces;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get customizationProfiles(): SeamHttpWorkspacesCustomizationProfiles;
    create(parameters?: WorkspacesCreateParameters, options?: WorkspacesCreateOptions): WorkspacesCreateRequest;
    findAnything(parameters?: WorkspacesFindAnythingParameters, options?: WorkspacesFindAnythingOptions): WorkspacesFindAnythingRequest;
    get(parameters?: WorkspacesGetParameters, options?: WorkspacesGetOptions): WorkspacesGetRequest;
    list(parameters?: WorkspacesListParameters, options?: WorkspacesListOptions): WorkspacesListRequest;
    resetSandbox(parameters?: WorkspacesResetSandboxParameters, options?: WorkspacesResetSandboxOptions): WorkspacesResetSandboxRequest;
    update(parameters?: WorkspacesUpdateParameters, options?: WorkspacesUpdateOptions): WorkspacesUpdateRequest;
}
type WorkspacesCreateParameters = RouteRequestBody<'/workspaces/create'>;
/**
 * @deprecated Use WorkspacesCreateParameters instead.
 */
type WorkspacesCreateBody = WorkspacesCreateParameters;
/**
 * @deprecated Use WorkspacesCreateRequest instead.
 */
type WorkspacesCreateResponse = SetNonNullable<Required<RouteResponse<'/workspaces/create'>>>;
type WorkspacesCreateRequest = SeamHttpRequest<WorkspacesCreateResponse, 'workspace'>;
interface WorkspacesCreateOptions {
}
type WorkspacesFindAnythingParameters = RouteRequestBody<'/workspaces/find_anything'>;
/**
 * @deprecated Use WorkspacesFindAnythingParameters instead.
 */
type WorkspacesFindAnythingParams = WorkspacesFindAnythingParameters;
/**
 * @deprecated Use WorkspacesFindAnythingRequest instead.
 */
type WorkspacesFindAnythingResponse = SetNonNullable<Required<RouteResponse<'/workspaces/find_anything'>>>;
type WorkspacesFindAnythingRequest = SeamHttpRequest<WorkspacesFindAnythingResponse, 'batch'>;
interface WorkspacesFindAnythingOptions {
}
type WorkspacesGetParameters = RouteRequestParams<'/workspaces/get'>;
/**
 * @deprecated Use WorkspacesGetParameters instead.
 */
type WorkspacesGetParams = WorkspacesGetParameters;
/**
 * @deprecated Use WorkspacesGetRequest instead.
 */
type WorkspacesGetResponse = SetNonNullable<Required<RouteResponse<'/workspaces/get'>>>;
type WorkspacesGetRequest = SeamHttpRequest<WorkspacesGetResponse, 'workspace'>;
interface WorkspacesGetOptions {
}
type WorkspacesListParameters = RouteRequestParams<'/workspaces/list'>;
/**
 * @deprecated Use WorkspacesListParameters instead.
 */
type WorkspacesListParams = WorkspacesListParameters;
/**
 * @deprecated Use WorkspacesListRequest instead.
 */
type WorkspacesListResponse = SetNonNullable<Required<RouteResponse<'/workspaces/list'>>>;
type WorkspacesListRequest = SeamHttpRequest<WorkspacesListResponse, 'workspaces'>;
interface WorkspacesListOptions {
}
type WorkspacesResetSandboxParameters = RouteRequestBody<'/workspaces/reset_sandbox'>;
/**
 * @deprecated Use WorkspacesResetSandboxParameters instead.
 */
type WorkspacesResetSandboxBody = WorkspacesResetSandboxParameters;
/**
 * @deprecated Use WorkspacesResetSandboxRequest instead.
 */
type WorkspacesResetSandboxResponse = SetNonNullable<Required<RouteResponse<'/workspaces/reset_sandbox'>>>;
type WorkspacesResetSandboxRequest = SeamHttpRequest<WorkspacesResetSandboxResponse, 'action_attempt'>;
type WorkspacesResetSandboxOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
type WorkspacesUpdateParameters = RouteRequestBody<'/workspaces/update'>;
/**
 * @deprecated Use WorkspacesUpdateParameters instead.
 */
type WorkspacesUpdateBody = WorkspacesUpdateParameters;
/**
 * @deprecated Use WorkspacesUpdateRequest instead.
 */
type WorkspacesUpdateResponse = SetNonNullable<Required<RouteResponse<'/workspaces/update'>>>;
type WorkspacesUpdateRequest = SeamHttpRequest<void, undefined>;
interface WorkspacesUpdateOptions {
}

declare class SeamHttp {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttp;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttp;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttp;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttp>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttp;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttp;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get accessCodes(): SeamHttpAccessCodes;
    get accessGrants(): SeamHttpAccessGrants;
    get accessMethods(): SeamHttpAccessMethods;
    get acs(): SeamHttpAcs;
    get actionAttempts(): SeamHttpActionAttempts;
    get bridges(): SeamHttpBridges;
    get clientSessions(): SeamHttpClientSessions;
    get connectWebviews(): SeamHttpConnectWebviews;
    get connectedAccounts(): SeamHttpConnectedAccounts;
    get customers(): SeamHttpCustomers;
    get devices(): SeamHttpDevices;
    get events(): SeamHttpEvents;
    get instantKeys(): SeamHttpInstantKeys;
    get locks(): SeamHttpLocks;
    get noiseSensors(): SeamHttpNoiseSensors;
    get phones(): SeamHttpPhones;
    get spaces(): SeamHttpSpaces;
    get thermostats(): SeamHttpThermostats;
    get unstablePartner(): SeamHttpUnstablePartner;
    get userIdentities(): SeamHttpUserIdentities;
    get webhooks(): SeamHttpWebhooks;
    get workspaces(): SeamHttpWorkspaces;
}

declare class SeamHttpEndpoints {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpEndpoints;
    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpEndpoints;
    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpEndpoints;
    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpEndpoints>;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'], workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'], options?: Omit<SeamHttpOptionsWithConsoleSessionToken, 'consoleSessionToken' | 'workspaceId'>): SeamHttpEndpoints;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'], workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'], options?: Omit<SeamHttpOptionsWithPersonalAccessToken, 'personalAccessToken' | 'workspaceId'>): SeamHttpEndpoints;
    createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(request: SeamHttpRequest<TResponse, TResponseKey>): SeamPaginator<TResponse, TResponseKey>;
    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
    get '/access_codes/create'(): (parameters?: AccessCodesCreateParameters, options?: AccessCodesCreateOptions) => AccessCodesCreateRequest;
    get '/access_codes/create_multiple'(): (parameters?: AccessCodesCreateMultipleParameters, options?: AccessCodesCreateMultipleOptions) => AccessCodesCreateMultipleRequest;
    get '/access_codes/delete'(): (parameters?: AccessCodesDeleteParameters, options?: AccessCodesDeleteOptions) => AccessCodesDeleteRequest;
    get '/access_codes/generate_code'(): (parameters?: AccessCodesGenerateCodeParameters, options?: AccessCodesGenerateCodeOptions) => AccessCodesGenerateCodeRequest;
    get '/access_codes/get'(): (parameters?: AccessCodesGetParameters, options?: AccessCodesGetOptions) => AccessCodesGetRequest;
    get '/access_codes/get_timeline'(): (parameters?: AccessCodesGetTimelineParameters, options?: AccessCodesGetTimelineOptions) => AccessCodesGetTimelineRequest;
    get '/access_codes/list'(): (parameters?: AccessCodesListParameters, options?: AccessCodesListOptions) => AccessCodesListRequest;
    get '/access_codes/pull_backup_access_code'(): (parameters?: AccessCodesPullBackupAccessCodeParameters, options?: AccessCodesPullBackupAccessCodeOptions) => AccessCodesPullBackupAccessCodeRequest;
    get '/access_codes/report_device_constraints'(): (parameters?: AccessCodesReportDeviceConstraintsParameters, options?: AccessCodesReportDeviceConstraintsOptions) => AccessCodesReportDeviceConstraintsRequest;
    get '/access_codes/update'(): (parameters?: AccessCodesUpdateParameters, options?: AccessCodesUpdateOptions) => AccessCodesUpdateRequest;
    get '/access_codes/update_multiple'(): (parameters?: AccessCodesUpdateMultipleParameters, options?: AccessCodesUpdateMultipleOptions) => AccessCodesUpdateMultipleRequest;
    get '/access_codes/simulate/create_unmanaged_access_code'(): (parameters?: AccessCodesSimulateCreateUnmanagedAccessCodeParameters, options?: AccessCodesSimulateCreateUnmanagedAccessCodeOptions) => AccessCodesSimulateCreateUnmanagedAccessCodeRequest;
    get '/access_codes/unmanaged/convert_to_managed'(): (parameters?: AccessCodesUnmanagedConvertToManagedParameters, options?: AccessCodesUnmanagedConvertToManagedOptions) => AccessCodesUnmanagedConvertToManagedRequest;
    get '/access_codes/unmanaged/delete'(): (parameters?: AccessCodesUnmanagedDeleteParameters, options?: AccessCodesUnmanagedDeleteOptions) => AccessCodesUnmanagedDeleteRequest;
    get '/access_codes/unmanaged/get'(): (parameters?: AccessCodesUnmanagedGetParameters, options?: AccessCodesUnmanagedGetOptions) => AccessCodesUnmanagedGetRequest;
    get '/access_codes/unmanaged/list'(): (parameters?: AccessCodesUnmanagedListParameters, options?: AccessCodesUnmanagedListOptions) => AccessCodesUnmanagedListRequest;
    get '/access_codes/unmanaged/update'(): (parameters?: AccessCodesUnmanagedUpdateParameters, options?: AccessCodesUnmanagedUpdateOptions) => AccessCodesUnmanagedUpdateRequest;
    get '/access_grants/create'(): (parameters?: AccessGrantsCreateParameters, options?: AccessGrantsCreateOptions) => AccessGrantsCreateRequest;
    get '/access_grants/delete'(): (parameters?: AccessGrantsDeleteParameters, options?: AccessGrantsDeleteOptions) => AccessGrantsDeleteRequest;
    get '/access_grants/get'(): (parameters?: AccessGrantsGetParameters, options?: AccessGrantsGetOptions) => AccessGrantsGetRequest;
    get '/access_grants/get_related'(): (parameters?: AccessGrantsGetRelatedParameters, options?: AccessGrantsGetRelatedOptions) => AccessGrantsGetRelatedRequest;
    get '/access_grants/list'(): (parameters?: AccessGrantsListParameters, options?: AccessGrantsListOptions) => AccessGrantsListRequest;
    get '/access_grants/request_access_methods'(): (parameters?: AccessGrantsRequestAccessMethodsParameters, options?: AccessGrantsRequestAccessMethodsOptions) => AccessGrantsRequestAccessMethodsRequest;
    get '/access_grants/update'(): (parameters?: AccessGrantsUpdateParameters, options?: AccessGrantsUpdateOptions) => AccessGrantsUpdateRequest;
    get '/access_grants/unmanaged/get'(): (parameters?: AccessGrantsUnmanagedGetParameters, options?: AccessGrantsUnmanagedGetOptions) => AccessGrantsUnmanagedGetRequest;
    get '/access_grants/unmanaged/list'(): (parameters?: AccessGrantsUnmanagedListParameters, options?: AccessGrantsUnmanagedListOptions) => AccessGrantsUnmanagedListRequest;
    get '/access_grants/unmanaged/update'(): (parameters?: AccessGrantsUnmanagedUpdateParameters, options?: AccessGrantsUnmanagedUpdateOptions) => AccessGrantsUnmanagedUpdateRequest;
    get '/access_methods/delete'(): (parameters?: AccessMethodsDeleteParameters, options?: AccessMethodsDeleteOptions) => AccessMethodsDeleteRequest;
    get '/access_methods/encode'(): (parameters?: AccessMethodsEncodeParameters, options?: AccessMethodsEncodeOptions) => AccessMethodsEncodeRequest;
    get '/access_methods/get'(): (parameters?: AccessMethodsGetParameters, options?: AccessMethodsGetOptions) => AccessMethodsGetRequest;
    get '/access_methods/get_related'(): (parameters?: AccessMethodsGetRelatedParameters, options?: AccessMethodsGetRelatedOptions) => AccessMethodsGetRelatedRequest;
    get '/access_methods/list'(): (parameters?: AccessMethodsListParameters, options?: AccessMethodsListOptions) => AccessMethodsListRequest;
    get '/access_methods/unmanaged/get'(): (parameters?: AccessMethodsUnmanagedGetParameters, options?: AccessMethodsUnmanagedGetOptions) => AccessMethodsUnmanagedGetRequest;
    get '/access_methods/unmanaged/list'(): (parameters?: AccessMethodsUnmanagedListParameters, options?: AccessMethodsUnmanagedListOptions) => AccessMethodsUnmanagedListRequest;
    get '/acs/access_groups/add_user'(): (parameters?: AcsAccessGroupsAddUserParameters, options?: AcsAccessGroupsAddUserOptions) => AcsAccessGroupsAddUserRequest;
    get '/acs/access_groups/delete'(): (parameters?: AcsAccessGroupsDeleteParameters, options?: AcsAccessGroupsDeleteOptions) => AcsAccessGroupsDeleteRequest;
    get '/acs/access_groups/get'(): (parameters?: AcsAccessGroupsGetParameters, options?: AcsAccessGroupsGetOptions) => AcsAccessGroupsGetRequest;
    get '/acs/access_groups/list'(): (parameters?: AcsAccessGroupsListParameters, options?: AcsAccessGroupsListOptions) => AcsAccessGroupsListRequest;
    get '/acs/access_groups/list_accessible_entrances'(): (parameters?: AcsAccessGroupsListAccessibleEntrancesParameters, options?: AcsAccessGroupsListAccessibleEntrancesOptions) => AcsAccessGroupsListAccessibleEntrancesRequest;
    get '/acs/access_groups/list_users'(): (parameters?: AcsAccessGroupsListUsersParameters, options?: AcsAccessGroupsListUsersOptions) => AcsAccessGroupsListUsersRequest;
    get '/acs/access_groups/remove_user'(): (parameters?: AcsAccessGroupsRemoveUserParameters, options?: AcsAccessGroupsRemoveUserOptions) => AcsAccessGroupsRemoveUserRequest;
    get '/acs/access_groups/unmanaged/get'(): (parameters?: AcsAccessGroupsUnmanagedGetParameters, options?: AcsAccessGroupsUnmanagedGetOptions) => AcsAccessGroupsUnmanagedGetRequest;
    get '/acs/access_groups/unmanaged/list'(): (parameters?: AcsAccessGroupsUnmanagedListParameters, options?: AcsAccessGroupsUnmanagedListOptions) => AcsAccessGroupsUnmanagedListRequest;
    get '/acs/credential_pools/list'(): (parameters?: AcsCredentialPoolsListParameters, options?: AcsCredentialPoolsListOptions) => AcsCredentialPoolsListRequest;
    get '/acs/credential_provisioning_automations/launch'(): (parameters?: AcsCredentialProvisioningAutomationsLaunchParameters, options?: AcsCredentialProvisioningAutomationsLaunchOptions) => AcsCredentialProvisioningAutomationsLaunchRequest;
    get '/acs/credentials/assign'(): (parameters?: AcsCredentialsAssignParameters, options?: AcsCredentialsAssignOptions) => AcsCredentialsAssignRequest;
    get '/acs/credentials/create'(): (parameters?: AcsCredentialsCreateParameters, options?: AcsCredentialsCreateOptions) => AcsCredentialsCreateRequest;
    get '/acs/credentials/create_offline_code'(): (parameters?: AcsCredentialsCreateOfflineCodeParameters, options?: AcsCredentialsCreateOfflineCodeOptions) => AcsCredentialsCreateOfflineCodeRequest;
    get '/acs/credentials/delete'(): (parameters?: AcsCredentialsDeleteParameters, options?: AcsCredentialsDeleteOptions) => AcsCredentialsDeleteRequest;
    get '/acs/credentials/get'(): (parameters?: AcsCredentialsGetParameters, options?: AcsCredentialsGetOptions) => AcsCredentialsGetRequest;
    get '/acs/credentials/list'(): (parameters?: AcsCredentialsListParameters, options?: AcsCredentialsListOptions) => AcsCredentialsListRequest;
    get '/acs/credentials/list_accessible_entrances'(): (parameters?: AcsCredentialsListAccessibleEntrancesParameters, options?: AcsCredentialsListAccessibleEntrancesOptions) => AcsCredentialsListAccessibleEntrancesRequest;
    get '/acs/credentials/unassign'(): (parameters?: AcsCredentialsUnassignParameters, options?: AcsCredentialsUnassignOptions) => AcsCredentialsUnassignRequest;
    get '/acs/credentials/update'(): (parameters?: AcsCredentialsUpdateParameters, options?: AcsCredentialsUpdateOptions) => AcsCredentialsUpdateRequest;
    get '/acs/credentials/unmanaged/get'(): (parameters?: AcsCredentialsUnmanagedGetParameters, options?: AcsCredentialsUnmanagedGetOptions) => AcsCredentialsUnmanagedGetRequest;
    get '/acs/credentials/unmanaged/list'(): (parameters?: AcsCredentialsUnmanagedListParameters, options?: AcsCredentialsUnmanagedListOptions) => AcsCredentialsUnmanagedListRequest;
    get '/acs/encoders/encode_credential'(): (parameters?: AcsEncodersEncodeCredentialParameters, options?: AcsEncodersEncodeCredentialOptions) => AcsEncodersEncodeCredentialRequest;
    get '/acs/encoders/get'(): (parameters?: AcsEncodersGetParameters, options?: AcsEncodersGetOptions) => AcsEncodersGetRequest;
    get '/acs/encoders/list'(): (parameters?: AcsEncodersListParameters, options?: AcsEncodersListOptions) => AcsEncodersListRequest;
    get '/acs/encoders/scan_credential'(): (parameters?: AcsEncodersScanCredentialParameters, options?: AcsEncodersScanCredentialOptions) => AcsEncodersScanCredentialRequest;
    get '/acs/encoders/simulate/next_credential_encode_will_fail'(): (parameters?: AcsEncodersSimulateNextCredentialEncodeWillFailParameters, options?: AcsEncodersSimulateNextCredentialEncodeWillFailOptions) => AcsEncodersSimulateNextCredentialEncodeWillFailRequest;
    get '/acs/encoders/simulate/next_credential_encode_will_succeed'(): (parameters?: AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters, options?: AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions) => AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest;
    get '/acs/encoders/simulate/next_credential_scan_will_fail'(): (parameters?: AcsEncodersSimulateNextCredentialScanWillFailParameters, options?: AcsEncodersSimulateNextCredentialScanWillFailOptions) => AcsEncodersSimulateNextCredentialScanWillFailRequest;
    get '/acs/encoders/simulate/next_credential_scan_will_succeed'(): (parameters?: AcsEncodersSimulateNextCredentialScanWillSucceedParameters, options?: AcsEncodersSimulateNextCredentialScanWillSucceedOptions) => AcsEncodersSimulateNextCredentialScanWillSucceedRequest;
    get '/acs/entrances/get'(): (parameters?: AcsEntrancesGetParameters, options?: AcsEntrancesGetOptions) => AcsEntrancesGetRequest;
    get '/acs/entrances/grant_access'(): (parameters?: AcsEntrancesGrantAccessParameters, options?: AcsEntrancesGrantAccessOptions) => AcsEntrancesGrantAccessRequest;
    get '/acs/entrances/list'(): (parameters?: AcsEntrancesListParameters, options?: AcsEntrancesListOptions) => AcsEntrancesListRequest;
    get '/acs/entrances/list_credentials_with_access'(): (parameters?: AcsEntrancesListCredentialsWithAccessParameters, options?: AcsEntrancesListCredentialsWithAccessOptions) => AcsEntrancesListCredentialsWithAccessRequest;
    get '/acs/entrances/unlock'(): (parameters?: AcsEntrancesUnlockParameters, options?: AcsEntrancesUnlockOptions) => AcsEntrancesUnlockRequest;
    get '/acs/systems/get'(): (parameters?: AcsSystemsGetParameters, options?: AcsSystemsGetOptions) => AcsSystemsGetRequest;
    get '/acs/systems/list'(): (parameters?: AcsSystemsListParameters, options?: AcsSystemsListOptions) => AcsSystemsListRequest;
    get '/acs/systems/list_compatible_credential_manager_acs_systems'(): (parameters?: AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters, options?: AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions) => AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest;
    get '/acs/systems/report_devices'(): (parameters?: AcsSystemsReportDevicesParameters, options?: AcsSystemsReportDevicesOptions) => AcsSystemsReportDevicesRequest;
    get '/acs/users/add_to_access_group'(): (parameters?: AcsUsersAddToAccessGroupParameters, options?: AcsUsersAddToAccessGroupOptions) => AcsUsersAddToAccessGroupRequest;
    get '/acs/users/create'(): (parameters?: AcsUsersCreateParameters, options?: AcsUsersCreateOptions) => AcsUsersCreateRequest;
    get '/acs/users/delete'(): (parameters?: AcsUsersDeleteParameters, options?: AcsUsersDeleteOptions) => AcsUsersDeleteRequest;
    get '/acs/users/get'(): (parameters?: AcsUsersGetParameters, options?: AcsUsersGetOptions) => AcsUsersGetRequest;
    get '/acs/users/list'(): (parameters?: AcsUsersListParameters, options?: AcsUsersListOptions) => AcsUsersListRequest;
    get '/acs/users/list_accessible_entrances'(): (parameters?: AcsUsersListAccessibleEntrancesParameters, options?: AcsUsersListAccessibleEntrancesOptions) => AcsUsersListAccessibleEntrancesRequest;
    get '/acs/users/remove_from_access_group'(): (parameters?: AcsUsersRemoveFromAccessGroupParameters, options?: AcsUsersRemoveFromAccessGroupOptions) => AcsUsersRemoveFromAccessGroupRequest;
    get '/acs/users/revoke_access_to_all_entrances'(): (parameters?: AcsUsersRevokeAccessToAllEntrancesParameters, options?: AcsUsersRevokeAccessToAllEntrancesOptions) => AcsUsersRevokeAccessToAllEntrancesRequest;
    get '/acs/users/suspend'(): (parameters?: AcsUsersSuspendParameters, options?: AcsUsersSuspendOptions) => AcsUsersSuspendRequest;
    get '/acs/users/unsuspend'(): (parameters?: AcsUsersUnsuspendParameters, options?: AcsUsersUnsuspendOptions) => AcsUsersUnsuspendRequest;
    get '/acs/users/update'(): (parameters?: AcsUsersUpdateParameters, options?: AcsUsersUpdateOptions) => AcsUsersUpdateRequest;
    get '/acs/users/unmanaged/get'(): (parameters?: AcsUsersUnmanagedGetParameters, options?: AcsUsersUnmanagedGetOptions) => AcsUsersUnmanagedGetRequest;
    get '/acs/users/unmanaged/list'(): (parameters?: AcsUsersUnmanagedListParameters, options?: AcsUsersUnmanagedListOptions) => AcsUsersUnmanagedListRequest;
    get '/action_attempts/get'(): (parameters?: ActionAttemptsGetParameters, options?: ActionAttemptsGetOptions) => ActionAttemptsGetRequest;
    get '/action_attempts/list'(): (parameters?: ActionAttemptsListParameters, options?: ActionAttemptsListOptions) => ActionAttemptsListRequest;
    get '/bridges/get'(): (parameters?: BridgesGetParameters, options?: BridgesGetOptions) => BridgesGetRequest;
    get '/bridges/list'(): (parameters?: BridgesListParameters, options?: BridgesListOptions) => BridgesListRequest;
    get '/client_sessions/create'(): (parameters?: ClientSessionsCreateParameters, options?: ClientSessionsCreateOptions) => ClientSessionsCreateRequest;
    get '/client_sessions/delete'(): (parameters?: ClientSessionsDeleteParameters, options?: ClientSessionsDeleteOptions) => ClientSessionsDeleteRequest;
    get '/client_sessions/get'(): (parameters?: ClientSessionsGetParameters, options?: ClientSessionsGetOptions) => ClientSessionsGetRequest;
    get '/client_sessions/get_or_create'(): (parameters?: ClientSessionsGetOrCreateParameters, options?: ClientSessionsGetOrCreateOptions) => ClientSessionsGetOrCreateRequest;
    get '/client_sessions/grant_access'(): (parameters?: ClientSessionsGrantAccessParameters, options?: ClientSessionsGrantAccessOptions) => ClientSessionsGrantAccessRequest;
    get '/client_sessions/list'(): (parameters?: ClientSessionsListParameters, options?: ClientSessionsListOptions) => ClientSessionsListRequest;
    get '/client_sessions/revoke'(): (parameters?: ClientSessionsRevokeParameters, options?: ClientSessionsRevokeOptions) => ClientSessionsRevokeRequest;
    get '/connect_webviews/create'(): (parameters?: ConnectWebviewsCreateParameters, options?: ConnectWebviewsCreateOptions) => ConnectWebviewsCreateRequest;
    get '/connect_webviews/delete'(): (parameters?: ConnectWebviewsDeleteParameters, options?: ConnectWebviewsDeleteOptions) => ConnectWebviewsDeleteRequest;
    get '/connect_webviews/get'(): (parameters?: ConnectWebviewsGetParameters, options?: ConnectWebviewsGetOptions) => ConnectWebviewsGetRequest;
    get '/connect_webviews/list'(): (parameters?: ConnectWebviewsListParameters, options?: ConnectWebviewsListOptions) => ConnectWebviewsListRequest;
    get '/connected_accounts/delete'(): (parameters?: ConnectedAccountsDeleteParameters, options?: ConnectedAccountsDeleteOptions) => ConnectedAccountsDeleteRequest;
    get '/connected_accounts/get'(): (parameters?: ConnectedAccountsGetParameters, options?: ConnectedAccountsGetOptions) => ConnectedAccountsGetRequest;
    get '/connected_accounts/list'(): (parameters?: ConnectedAccountsListParameters, options?: ConnectedAccountsListOptions) => ConnectedAccountsListRequest;
    get '/connected_accounts/sync'(): (parameters?: ConnectedAccountsSyncParameters, options?: ConnectedAccountsSyncOptions) => ConnectedAccountsSyncRequest;
    get '/connected_accounts/update'(): (parameters?: ConnectedAccountsUpdateParameters, options?: ConnectedAccountsUpdateOptions) => ConnectedAccountsUpdateRequest;
    get '/connected_accounts/simulate/disconnect'(): (parameters?: ConnectedAccountsSimulateDisconnectParameters, options?: ConnectedAccountsSimulateDisconnectOptions) => ConnectedAccountsSimulateDisconnectRequest;
    get '/customers/create_portal'(): (parameters?: CustomersCreatePortalParameters, options?: CustomersCreatePortalOptions) => CustomersCreatePortalRequest;
    get '/customers/delete_data'(): (parameters?: CustomersDeleteDataParameters, options?: CustomersDeleteDataOptions) => CustomersDeleteDataRequest;
    get '/customers/push_data'(): (parameters?: CustomersPushDataParameters, options?: CustomersPushDataOptions) => CustomersPushDataRequest;
    get '/customers/reservations/create_deep_link'(): (parameters?: CustomersReservationsCreateDeepLinkParameters, options?: CustomersReservationsCreateDeepLinkOptions) => CustomersReservationsCreateDeepLinkRequest;
    get '/devices/delete'(): (parameters?: DevicesDeleteParameters, options?: DevicesDeleteOptions) => DevicesDeleteRequest;
    get '/devices/get'(): (parameters?: DevicesGetParameters, options?: DevicesGetOptions) => DevicesGetRequest;
    get '/devices/list'(): (parameters?: DevicesListParameters, options?: DevicesListOptions) => DevicesListRequest;
    get '/devices/list_device_providers'(): (parameters?: DevicesListDeviceProvidersParameters, options?: DevicesListDeviceProvidersOptions) => DevicesListDeviceProvidersRequest;
    get '/devices/report_provider_metadata'(): (parameters?: DevicesReportProviderMetadataParameters, options?: DevicesReportProviderMetadataOptions) => DevicesReportProviderMetadataRequest;
    get '/devices/update'(): (parameters?: DevicesUpdateParameters, options?: DevicesUpdateOptions) => DevicesUpdateRequest;
    get '/devices/simulate/connect'(): (parameters?: DevicesSimulateConnectParameters, options?: DevicesSimulateConnectOptions) => DevicesSimulateConnectRequest;
    get '/devices/simulate/connect_to_hub'(): (parameters?: DevicesSimulateConnectToHubParameters, options?: DevicesSimulateConnectToHubOptions) => DevicesSimulateConnectToHubRequest;
    get '/devices/simulate/disconnect'(): (parameters?: DevicesSimulateDisconnectParameters, options?: DevicesSimulateDisconnectOptions) => DevicesSimulateDisconnectRequest;
    get '/devices/simulate/disconnect_from_hub'(): (parameters?: DevicesSimulateDisconnectFromHubParameters, options?: DevicesSimulateDisconnectFromHubOptions) => DevicesSimulateDisconnectFromHubRequest;
    get '/devices/simulate/paid_subscription'(): (parameters?: DevicesSimulatePaidSubscriptionParameters, options?: DevicesSimulatePaidSubscriptionOptions) => DevicesSimulatePaidSubscriptionRequest;
    get '/devices/simulate/remove'(): (parameters?: DevicesSimulateRemoveParameters, options?: DevicesSimulateRemoveOptions) => DevicesSimulateRemoveRequest;
    get '/devices/unmanaged/get'(): (parameters?: DevicesUnmanagedGetParameters, options?: DevicesUnmanagedGetOptions) => DevicesUnmanagedGetRequest;
    get '/devices/unmanaged/list'(): (parameters?: DevicesUnmanagedListParameters, options?: DevicesUnmanagedListOptions) => DevicesUnmanagedListRequest;
    get '/devices/unmanaged/update'(): (parameters?: DevicesUnmanagedUpdateParameters, options?: DevicesUnmanagedUpdateOptions) => DevicesUnmanagedUpdateRequest;
    get '/events/get'(): (parameters?: EventsGetParameters, options?: EventsGetOptions) => EventsGetRequest;
    get '/events/list'(): (parameters?: EventsListParameters, options?: EventsListOptions) => EventsListRequest;
    get '/instant_keys/delete'(): (parameters?: InstantKeysDeleteParameters, options?: InstantKeysDeleteOptions) => InstantKeysDeleteRequest;
    get '/instant_keys/get'(): (parameters?: InstantKeysGetParameters, options?: InstantKeysGetOptions) => InstantKeysGetRequest;
    get '/instant_keys/list'(): (parameters?: InstantKeysListParameters, options?: InstantKeysListOptions) => InstantKeysListRequest;
    get '/locks/configure_auto_lock'(): (parameters?: LocksConfigureAutoLockParameters, options?: LocksConfigureAutoLockOptions) => LocksConfigureAutoLockRequest;
    get '/locks/get'(): (parameters?: LocksGetParameters, options?: LocksGetOptions) => LocksGetRequest;
    get '/locks/list'(): (parameters?: LocksListParameters, options?: LocksListOptions) => LocksListRequest;
    get '/locks/lock_door'(): (parameters?: LocksLockDoorParameters, options?: LocksLockDoorOptions) => LocksLockDoorRequest;
    get '/locks/unlock_door'(): (parameters?: LocksUnlockDoorParameters, options?: LocksUnlockDoorOptions) => LocksUnlockDoorRequest;
    get '/locks/simulate/keypad_code_entry'(): (parameters?: LocksSimulateKeypadCodeEntryParameters, options?: LocksSimulateKeypadCodeEntryOptions) => LocksSimulateKeypadCodeEntryRequest;
    get '/locks/simulate/manual_lock_via_keypad'(): (parameters?: LocksSimulateManualLockViaKeypadParameters, options?: LocksSimulateManualLockViaKeypadOptions) => LocksSimulateManualLockViaKeypadRequest;
    get '/noise_sensors/list'(): (parameters?: NoiseSensorsListParameters, options?: NoiseSensorsListOptions) => NoiseSensorsListRequest;
    get '/noise_sensors/noise_thresholds/create'(): (parameters?: NoiseSensorsNoiseThresholdsCreateParameters, options?: NoiseSensorsNoiseThresholdsCreateOptions) => NoiseSensorsNoiseThresholdsCreateRequest;
    get '/noise_sensors/noise_thresholds/delete'(): (parameters?: NoiseSensorsNoiseThresholdsDeleteParameters, options?: NoiseSensorsNoiseThresholdsDeleteOptions) => NoiseSensorsNoiseThresholdsDeleteRequest;
    get '/noise_sensors/noise_thresholds/get'(): (parameters?: NoiseSensorsNoiseThresholdsGetParameters, options?: NoiseSensorsNoiseThresholdsGetOptions) => NoiseSensorsNoiseThresholdsGetRequest;
    get '/noise_sensors/noise_thresholds/list'(): (parameters?: NoiseSensorsNoiseThresholdsListParameters, options?: NoiseSensorsNoiseThresholdsListOptions) => NoiseSensorsNoiseThresholdsListRequest;
    get '/noise_sensors/noise_thresholds/update'(): (parameters?: NoiseSensorsNoiseThresholdsUpdateParameters, options?: NoiseSensorsNoiseThresholdsUpdateOptions) => NoiseSensorsNoiseThresholdsUpdateRequest;
    get '/noise_sensors/simulate/trigger_noise_threshold'(): (parameters?: NoiseSensorsSimulateTriggerNoiseThresholdParameters, options?: NoiseSensorsSimulateTriggerNoiseThresholdOptions) => NoiseSensorsSimulateTriggerNoiseThresholdRequest;
    get '/phones/deactivate'(): (parameters?: PhonesDeactivateParameters, options?: PhonesDeactivateOptions) => PhonesDeactivateRequest;
    get '/phones/get'(): (parameters?: PhonesGetParameters, options?: PhonesGetOptions) => PhonesGetRequest;
    get '/phones/list'(): (parameters?: PhonesListParameters, options?: PhonesListOptions) => PhonesListRequest;
    get '/phones/simulate/create_sandbox_phone'(): (parameters?: PhonesSimulateCreateSandboxPhoneParameters, options?: PhonesSimulateCreateSandboxPhoneOptions) => PhonesSimulateCreateSandboxPhoneRequest;
    get '/seam/console/v1/get_resource_locator'(): (parameters?: SeamConsoleV1GetResourceLocatorParameters, options?: SeamConsoleV1GetResourceLocatorOptions) => SeamConsoleV1GetResourceLocatorRequest;
    get '/seam/console/v1/timelines/get'(): (parameters?: SeamConsoleV1TimelinesGetParameters, options?: SeamConsoleV1TimelinesGetOptions) => SeamConsoleV1TimelinesGetRequest;
    get '/seam/customer/v1/access_grants/list'(): (parameters?: SeamCustomerV1AccessGrantsListParameters, options?: SeamCustomerV1AccessGrantsListOptions) => SeamCustomerV1AccessGrantsListRequest;
    get '/seam/customer/v1/access_grants/update'(): (parameters?: SeamCustomerV1AccessGrantsUpdateParameters, options?: SeamCustomerV1AccessGrantsUpdateOptions) => SeamCustomerV1AccessGrantsUpdateRequest;
    get '/seam/customer/v1/access_methods/encode'(): (parameters?: SeamCustomerV1AccessMethodsEncodeParameters, options?: SeamCustomerV1AccessMethodsEncodeOptions) => SeamCustomerV1AccessMethodsEncodeRequest;
    get '/seam/customer/v1/automation_runs/list'(): (parameters?: SeamCustomerV1AutomationRunsListParameters, options?: SeamCustomerV1AutomationRunsListOptions) => SeamCustomerV1AutomationRunsListRequest;
    get '/seam/customer/v1/automations/delete'(): (parameters?: SeamCustomerV1AutomationsDeleteParameters, options?: SeamCustomerV1AutomationsDeleteOptions) => SeamCustomerV1AutomationsDeleteRequest;
    get '/seam/customer/v1/automations/get'(): (parameters?: SeamCustomerV1AutomationsGetParameters, options?: SeamCustomerV1AutomationsGetOptions) => SeamCustomerV1AutomationsGetRequest;
    get '/seam/customer/v1/automations/update'(): (parameters?: SeamCustomerV1AutomationsUpdateParameters, options?: SeamCustomerV1AutomationsUpdateOptions) => SeamCustomerV1AutomationsUpdateRequest;
    get '/seam/customer/v1/connector_customers/list'(): (parameters?: SeamCustomerV1ConnectorCustomersListParameters, options?: SeamCustomerV1ConnectorCustomersListOptions) => SeamCustomerV1ConnectorCustomersListRequest;
    get '/seam/customer/v1/connectors/authorize'(): (parameters?: SeamCustomerV1ConnectorsAuthorizeParameters, options?: SeamCustomerV1ConnectorsAuthorizeOptions) => SeamCustomerV1ConnectorsAuthorizeRequest;
    get '/seam/customer/v1/connectors/connector_types'(): (parameters?: SeamCustomerV1ConnectorsConnectorTypesParameters, options?: SeamCustomerV1ConnectorsConnectorTypesOptions) => SeamCustomerV1ConnectorsConnectorTypesRequest;
    get '/seam/customer/v1/connectors/create'(): (parameters?: SeamCustomerV1ConnectorsCreateParameters, options?: SeamCustomerV1ConnectorsCreateOptions) => SeamCustomerV1ConnectorsCreateRequest;
    get '/seam/customer/v1/connectors/delete'(): (parameters?: SeamCustomerV1ConnectorsDeleteParameters, options?: SeamCustomerV1ConnectorsDeleteOptions) => SeamCustomerV1ConnectorsDeleteRequest;
    get '/seam/customer/v1/connectors/list'(): (parameters?: SeamCustomerV1ConnectorsListParameters, options?: SeamCustomerV1ConnectorsListOptions) => SeamCustomerV1ConnectorsListRequest;
    get '/seam/customer/v1/connectors/sync'(): (parameters?: SeamCustomerV1ConnectorsSyncParameters, options?: SeamCustomerV1ConnectorsSyncOptions) => SeamCustomerV1ConnectorsSyncRequest;
    get '/seam/customer/v1/connectors/update'(): (parameters?: SeamCustomerV1ConnectorsUpdateParameters, options?: SeamCustomerV1ConnectorsUpdateOptions) => SeamCustomerV1ConnectorsUpdateRequest;
    get '/seam/customer/v1/connectors/ical/validate-config'(): (parameters?: SeamCustomerV1ConnectorsIcalValidateConfigParameters, options?: SeamCustomerV1ConnectorsIcalValidateConfigOptions) => SeamCustomerV1ConnectorsIcalValidateConfigRequest;
    get '/seam/customer/v1/customers/automations/get'(): (parameters?: SeamCustomerV1CustomersAutomationsGetParameters, options?: SeamCustomerV1CustomersAutomationsGetOptions) => SeamCustomerV1CustomersAutomationsGetRequest;
    get '/seam/customer/v1/customers/automations/update'(): (parameters?: SeamCustomerV1CustomersAutomationsUpdateParameters, options?: SeamCustomerV1CustomersAutomationsUpdateOptions) => SeamCustomerV1CustomersAutomationsUpdateRequest;
    get '/seam/customer/v1/customers/list'(): (parameters?: SeamCustomerV1CustomersListParameters, options?: SeamCustomerV1CustomersListOptions) => SeamCustomerV1CustomersListRequest;
    get '/seam/customer/v1/customers/me'(): (parameters?: SeamCustomerV1CustomersMeParameters, options?: SeamCustomerV1CustomersMeOptions) => SeamCustomerV1CustomersMeRequest;
    get '/seam/customer/v1/customers/open_portal'(): (parameters?: SeamCustomerV1CustomersOpenPortalParameters, options?: SeamCustomerV1CustomersOpenPortalOptions) => SeamCustomerV1CustomersOpenPortalRequest;
    get '/seam/customer/v1/encoders/list'(): (parameters?: SeamCustomerV1EncodersListParameters, options?: SeamCustomerV1EncodersListOptions) => SeamCustomerV1EncodersListRequest;
    get '/seam/customer/v1/events/list'(): (parameters?: SeamCustomerV1EventsListParameters, options?: SeamCustomerV1EventsListOptions) => SeamCustomerV1EventsListRequest;
    get '/seam/customer/v1/portals/get'(): (parameters?: SeamCustomerV1PortalsGetParameters, options?: SeamCustomerV1PortalsGetOptions) => SeamCustomerV1PortalsGetRequest;
    get '/seam/customer/v1/portals/update'(): (parameters?: SeamCustomerV1PortalsUpdateParameters, options?: SeamCustomerV1PortalsUpdateOptions) => SeamCustomerV1PortalsUpdateRequest;
    get '/seam/customer/v1/reservations/get'(): (parameters?: SeamCustomerV1ReservationsGetParameters, options?: SeamCustomerV1ReservationsGetOptions) => SeamCustomerV1ReservationsGetRequest;
    get '/seam/customer/v1/reservations/list'(): (parameters?: SeamCustomerV1ReservationsListParameters, options?: SeamCustomerV1ReservationsListOptions) => SeamCustomerV1ReservationsListRequest;
    get '/seam/customer/v1/reservations/list_access_grants'(): (parameters?: SeamCustomerV1ReservationsListAccessGrantsParameters, options?: SeamCustomerV1ReservationsListAccessGrantsOptions) => SeamCustomerV1ReservationsListAccessGrantsRequest;
    get '/seam/customer/v1/settings/get'(): (parameters?: SeamCustomerV1SettingsGetParameters, options?: SeamCustomerV1SettingsGetOptions) => SeamCustomerV1SettingsGetRequest;
    get '/seam/customer/v1/settings/update'(): (parameters?: SeamCustomerV1SettingsUpdateParameters, options?: SeamCustomerV1SettingsUpdateOptions) => SeamCustomerV1SettingsUpdateRequest;
    get '/seam/customer/v1/settings/vertical_resource_aliases/get'(): (parameters?: SeamCustomerV1SettingsVerticalResourceAliasesGetParameters, options?: SeamCustomerV1SettingsVerticalResourceAliasesGetOptions) => SeamCustomerV1SettingsVerticalResourceAliasesGetRequest;
    get '/seam/customer/v1/spaces/create'(): (parameters?: SeamCustomerV1SpacesCreateParameters, options?: SeamCustomerV1SpacesCreateOptions) => SeamCustomerV1SpacesCreateRequest;
    get '/seam/customer/v1/spaces/list'(): (parameters?: SeamCustomerV1SpacesListParameters, options?: SeamCustomerV1SpacesListOptions) => SeamCustomerV1SpacesListRequest;
    get '/seam/customer/v1/spaces/list_reservations'(): (parameters?: SeamCustomerV1SpacesListReservationsParameters, options?: SeamCustomerV1SpacesListReservationsOptions) => SeamCustomerV1SpacesListReservationsRequest;
    get '/seam/customer/v1/spaces/push_common_areas'(): (parameters?: SeamCustomerV1SpacesPushCommonAreasParameters, options?: SeamCustomerV1SpacesPushCommonAreasOptions) => SeamCustomerV1SpacesPushCommonAreasRequest;
    get '/seam/customer/v1/staff_members/get'(): (parameters?: SeamCustomerV1StaffMembersGetParameters, options?: SeamCustomerV1StaffMembersGetOptions) => SeamCustomerV1StaffMembersGetRequest;
    get '/seam/customer/v1/staff_members/list'(): (parameters?: SeamCustomerV1StaffMembersListParameters, options?: SeamCustomerV1StaffMembersListOptions) => SeamCustomerV1StaffMembersListRequest;
    get '/seam/partner/v1/building_blocks/spaces/auto_map'(): (parameters?: SeamPartnerV1BuildingBlocksSpacesAutoMapParameters, options?: SeamPartnerV1BuildingBlocksSpacesAutoMapOptions) => SeamPartnerV1BuildingBlocksSpacesAutoMapRequest;
    get '/spaces/add_acs_entrances'(): (parameters?: SpacesAddAcsEntrancesParameters, options?: SpacesAddAcsEntrancesOptions) => SpacesAddAcsEntrancesRequest;
    get '/spaces/add_connected_account'(): (parameters?: SpacesAddConnectedAccountParameters, options?: SpacesAddConnectedAccountOptions) => SpacesAddConnectedAccountRequest;
    get '/spaces/add_devices'(): (parameters?: SpacesAddDevicesParameters, options?: SpacesAddDevicesOptions) => SpacesAddDevicesRequest;
    get '/spaces/create'(): (parameters?: SpacesCreateParameters, options?: SpacesCreateOptions) => SpacesCreateRequest;
    get '/spaces/delete'(): (parameters?: SpacesDeleteParameters, options?: SpacesDeleteOptions) => SpacesDeleteRequest;
    get '/spaces/get'(): (parameters?: SpacesGetParameters, options?: SpacesGetOptions) => SpacesGetRequest;
    get '/spaces/get_related'(): (parameters?: SpacesGetRelatedParameters, options?: SpacesGetRelatedOptions) => SpacesGetRelatedRequest;
    get '/spaces/list'(): (parameters?: SpacesListParameters, options?: SpacesListOptions) => SpacesListRequest;
    get '/spaces/remove_acs_entrances'(): (parameters?: SpacesRemoveAcsEntrancesParameters, options?: SpacesRemoveAcsEntrancesOptions) => SpacesRemoveAcsEntrancesRequest;
    get '/spaces/remove_connected_account'(): (parameters?: SpacesRemoveConnectedAccountParameters, options?: SpacesRemoveConnectedAccountOptions) => SpacesRemoveConnectedAccountRequest;
    get '/spaces/remove_devices'(): (parameters?: SpacesRemoveDevicesParameters, options?: SpacesRemoveDevicesOptions) => SpacesRemoveDevicesRequest;
    get '/spaces/update'(): (parameters?: SpacesUpdateParameters, options?: SpacesUpdateOptions) => SpacesUpdateRequest;
    get '/thermostats/activate_climate_preset'(): (parameters?: ThermostatsActivateClimatePresetParameters, options?: ThermostatsActivateClimatePresetOptions) => ThermostatsActivateClimatePresetRequest;
    get '/thermostats/cool'(): (parameters?: ThermostatsCoolParameters, options?: ThermostatsCoolOptions) => ThermostatsCoolRequest;
    get '/thermostats/create_climate_preset'(): (parameters?: ThermostatsCreateClimatePresetParameters, options?: ThermostatsCreateClimatePresetOptions) => ThermostatsCreateClimatePresetRequest;
    get '/thermostats/delete_climate_preset'(): (parameters?: ThermostatsDeleteClimatePresetParameters, options?: ThermostatsDeleteClimatePresetOptions) => ThermostatsDeleteClimatePresetRequest;
    get '/thermostats/get'(): (parameters?: ThermostatsGetParameters, options?: ThermostatsGetOptions) => ThermostatsGetRequest;
    get '/thermostats/heat'(): (parameters?: ThermostatsHeatParameters, options?: ThermostatsHeatOptions) => ThermostatsHeatRequest;
    get '/thermostats/heat_cool'(): (parameters?: ThermostatsHeatCoolParameters, options?: ThermostatsHeatCoolOptions) => ThermostatsHeatCoolRequest;
    get '/thermostats/list'(): (parameters?: ThermostatsListParameters, options?: ThermostatsListOptions) => ThermostatsListRequest;
    get '/thermostats/off'(): (parameters?: ThermostatsOffParameters, options?: ThermostatsOffOptions) => ThermostatsOffRequest;
    get '/thermostats/set_fallback_climate_preset'(): (parameters?: ThermostatsSetFallbackClimatePresetParameters, options?: ThermostatsSetFallbackClimatePresetOptions) => ThermostatsSetFallbackClimatePresetRequest;
    get '/thermostats/set_fan_mode'(): (parameters?: ThermostatsSetFanModeParameters, options?: ThermostatsSetFanModeOptions) => ThermostatsSetFanModeRequest;
    get '/thermostats/set_hvac_mode'(): (parameters?: ThermostatsSetHvacModeParameters, options?: ThermostatsSetHvacModeOptions) => ThermostatsSetHvacModeRequest;
    get '/thermostats/set_temperature_threshold'(): (parameters?: ThermostatsSetTemperatureThresholdParameters, options?: ThermostatsSetTemperatureThresholdOptions) => ThermostatsSetTemperatureThresholdRequest;
    get '/thermostats/update_climate_preset'(): (parameters?: ThermostatsUpdateClimatePresetParameters, options?: ThermostatsUpdateClimatePresetOptions) => ThermostatsUpdateClimatePresetRequest;
    get '/thermostats/update_weekly_program'(): (parameters?: ThermostatsUpdateWeeklyProgramParameters, options?: ThermostatsUpdateWeeklyProgramOptions) => ThermostatsUpdateWeeklyProgramRequest;
    get '/thermostats/daily_programs/create'(): (parameters?: ThermostatsDailyProgramsCreateParameters, options?: ThermostatsDailyProgramsCreateOptions) => ThermostatsDailyProgramsCreateRequest;
    get '/thermostats/daily_programs/delete'(): (parameters?: ThermostatsDailyProgramsDeleteParameters, options?: ThermostatsDailyProgramsDeleteOptions) => ThermostatsDailyProgramsDeleteRequest;
    get '/thermostats/daily_programs/update'(): (parameters?: ThermostatsDailyProgramsUpdateParameters, options?: ThermostatsDailyProgramsUpdateOptions) => ThermostatsDailyProgramsUpdateRequest;
    get '/thermostats/schedules/create'(): (parameters?: ThermostatsSchedulesCreateParameters, options?: ThermostatsSchedulesCreateOptions) => ThermostatsSchedulesCreateRequest;
    get '/thermostats/schedules/delete'(): (parameters?: ThermostatsSchedulesDeleteParameters, options?: ThermostatsSchedulesDeleteOptions) => ThermostatsSchedulesDeleteRequest;
    get '/thermostats/schedules/get'(): (parameters?: ThermostatsSchedulesGetParameters, options?: ThermostatsSchedulesGetOptions) => ThermostatsSchedulesGetRequest;
    get '/thermostats/schedules/list'(): (parameters?: ThermostatsSchedulesListParameters, options?: ThermostatsSchedulesListOptions) => ThermostatsSchedulesListRequest;
    get '/thermostats/schedules/update'(): (parameters?: ThermostatsSchedulesUpdateParameters, options?: ThermostatsSchedulesUpdateOptions) => ThermostatsSchedulesUpdateRequest;
    get '/thermostats/simulate/hvac_mode_adjusted'(): (parameters?: ThermostatsSimulateHvacModeAdjustedParameters, options?: ThermostatsSimulateHvacModeAdjustedOptions) => ThermostatsSimulateHvacModeAdjustedRequest;
    get '/thermostats/simulate/temperature_reached'(): (parameters?: ThermostatsSimulateTemperatureReachedParameters, options?: ThermostatsSimulateTemperatureReachedOptions) => ThermostatsSimulateTemperatureReachedRequest;
    get '/unstable_partner/building_blocks/connect_accounts'(): (parameters?: UnstablePartnerBuildingBlocksConnectAccountsParameters, options?: UnstablePartnerBuildingBlocksConnectAccountsOptions) => UnstablePartnerBuildingBlocksConnectAccountsRequest;
    get '/unstable_partner/building_blocks/generate_magic_link'(): (parameters?: UnstablePartnerBuildingBlocksGenerateMagicLinkParameters, options?: UnstablePartnerBuildingBlocksGenerateMagicLinkOptions) => UnstablePartnerBuildingBlocksGenerateMagicLinkRequest;
    get '/unstable_partner/building_blocks/manage_devices'(): (parameters?: UnstablePartnerBuildingBlocksManageDevicesParameters, options?: UnstablePartnerBuildingBlocksManageDevicesOptions) => UnstablePartnerBuildingBlocksManageDevicesRequest;
    get '/unstable_partner/building_blocks/organize_spaces'(): (parameters?: UnstablePartnerBuildingBlocksOrganizeSpacesParameters, options?: UnstablePartnerBuildingBlocksOrganizeSpacesOptions) => UnstablePartnerBuildingBlocksOrganizeSpacesRequest;
    get '/user_identities/add_acs_user'(): (parameters?: UserIdentitiesAddAcsUserParameters, options?: UserIdentitiesAddAcsUserOptions) => UserIdentitiesAddAcsUserRequest;
    get '/user_identities/create'(): (parameters?: UserIdentitiesCreateParameters, options?: UserIdentitiesCreateOptions) => UserIdentitiesCreateRequest;
    get '/user_identities/delete'(): (parameters?: UserIdentitiesDeleteParameters, options?: UserIdentitiesDeleteOptions) => UserIdentitiesDeleteRequest;
    get '/user_identities/generate_instant_key'(): (parameters?: UserIdentitiesGenerateInstantKeyParameters, options?: UserIdentitiesGenerateInstantKeyOptions) => UserIdentitiesGenerateInstantKeyRequest;
    get '/user_identities/get'(): (parameters?: UserIdentitiesGetParameters, options?: UserIdentitiesGetOptions) => UserIdentitiesGetRequest;
    get '/user_identities/grant_access_to_device'(): (parameters?: UserIdentitiesGrantAccessToDeviceParameters, options?: UserIdentitiesGrantAccessToDeviceOptions) => UserIdentitiesGrantAccessToDeviceRequest;
    get '/user_identities/list'(): (parameters?: UserIdentitiesListParameters, options?: UserIdentitiesListOptions) => UserIdentitiesListRequest;
    get '/user_identities/list_accessible_devices'(): (parameters?: UserIdentitiesListAccessibleDevicesParameters, options?: UserIdentitiesListAccessibleDevicesOptions) => UserIdentitiesListAccessibleDevicesRequest;
    get '/user_identities/list_accessible_entrances'(): (parameters?: UserIdentitiesListAccessibleEntrancesParameters, options?: UserIdentitiesListAccessibleEntrancesOptions) => UserIdentitiesListAccessibleEntrancesRequest;
    get '/user_identities/list_acs_systems'(): (parameters?: UserIdentitiesListAcsSystemsParameters, options?: UserIdentitiesListAcsSystemsOptions) => UserIdentitiesListAcsSystemsRequest;
    get '/user_identities/list_acs_users'(): (parameters?: UserIdentitiesListAcsUsersParameters, options?: UserIdentitiesListAcsUsersOptions) => UserIdentitiesListAcsUsersRequest;
    get '/user_identities/remove_acs_user'(): (parameters?: UserIdentitiesRemoveAcsUserParameters, options?: UserIdentitiesRemoveAcsUserOptions) => UserIdentitiesRemoveAcsUserRequest;
    get '/user_identities/revoke_access_to_device'(): (parameters?: UserIdentitiesRevokeAccessToDeviceParameters, options?: UserIdentitiesRevokeAccessToDeviceOptions) => UserIdentitiesRevokeAccessToDeviceRequest;
    get '/user_identities/update'(): (parameters?: UserIdentitiesUpdateParameters, options?: UserIdentitiesUpdateOptions) => UserIdentitiesUpdateRequest;
    get '/user_identities/enrollment_automations/delete'(): (parameters?: UserIdentitiesEnrollmentAutomationsDeleteParameters, options?: UserIdentitiesEnrollmentAutomationsDeleteOptions) => UserIdentitiesEnrollmentAutomationsDeleteRequest;
    get '/user_identities/enrollment_automations/get'(): (parameters?: UserIdentitiesEnrollmentAutomationsGetParameters, options?: UserIdentitiesEnrollmentAutomationsGetOptions) => UserIdentitiesEnrollmentAutomationsGetRequest;
    get '/user_identities/enrollment_automations/launch'(): (parameters?: UserIdentitiesEnrollmentAutomationsLaunchParameters, options?: UserIdentitiesEnrollmentAutomationsLaunchOptions) => UserIdentitiesEnrollmentAutomationsLaunchRequest;
    get '/user_identities/enrollment_automations/list'(): (parameters?: UserIdentitiesEnrollmentAutomationsListParameters, options?: UserIdentitiesEnrollmentAutomationsListOptions) => UserIdentitiesEnrollmentAutomationsListRequest;
    get '/user_identities/unmanaged/get'(): (parameters?: UserIdentitiesUnmanagedGetParameters, options?: UserIdentitiesUnmanagedGetOptions) => UserIdentitiesUnmanagedGetRequest;
    get '/user_identities/unmanaged/list'(): (parameters?: UserIdentitiesUnmanagedListParameters, options?: UserIdentitiesUnmanagedListOptions) => UserIdentitiesUnmanagedListRequest;
    get '/user_identities/unmanaged/update'(): (parameters?: UserIdentitiesUnmanagedUpdateParameters, options?: UserIdentitiesUnmanagedUpdateOptions) => UserIdentitiesUnmanagedUpdateRequest;
    get '/webhooks/create'(): (parameters?: WebhooksCreateParameters, options?: WebhooksCreateOptions) => WebhooksCreateRequest;
    get '/webhooks/delete'(): (parameters?: WebhooksDeleteParameters, options?: WebhooksDeleteOptions) => WebhooksDeleteRequest;
    get '/webhooks/get'(): (parameters?: WebhooksGetParameters, options?: WebhooksGetOptions) => WebhooksGetRequest;
    get '/webhooks/list'(): (parameters?: WebhooksListParameters, options?: WebhooksListOptions) => WebhooksListRequest;
    get '/webhooks/update'(): (parameters?: WebhooksUpdateParameters, options?: WebhooksUpdateOptions) => WebhooksUpdateRequest;
    get '/workspaces/create'(): (parameters?: WorkspacesCreateParameters, options?: WorkspacesCreateOptions) => WorkspacesCreateRequest;
    get '/workspaces/find_anything'(): (parameters?: WorkspacesFindAnythingParameters, options?: WorkspacesFindAnythingOptions) => WorkspacesFindAnythingRequest;
    get '/workspaces/get'(): (parameters?: WorkspacesGetParameters, options?: WorkspacesGetOptions) => WorkspacesGetRequest;
    get '/workspaces/list'(): (parameters?: WorkspacesListParameters, options?: WorkspacesListOptions) => WorkspacesListRequest;
    get '/workspaces/reset_sandbox'(): (parameters?: WorkspacesResetSandboxParameters, options?: WorkspacesResetSandboxOptions) => WorkspacesResetSandboxRequest;
    get '/workspaces/update'(): (parameters?: WorkspacesUpdateParameters, options?: WorkspacesUpdateOptions) => WorkspacesUpdateRequest;
    get '/workspaces/customization_profiles/create'(): (parameters?: WorkspacesCustomizationProfilesCreateParameters, options?: WorkspacesCustomizationProfilesCreateOptions) => WorkspacesCustomizationProfilesCreateRequest;
    get '/workspaces/customization_profiles/get'(): (parameters?: WorkspacesCustomizationProfilesGetParameters, options?: WorkspacesCustomizationProfilesGetOptions) => WorkspacesCustomizationProfilesGetRequest;
    get '/workspaces/customization_profiles/list'(): (parameters?: WorkspacesCustomizationProfilesListParameters, options?: WorkspacesCustomizationProfilesListOptions) => WorkspacesCustomizationProfilesListRequest;
    get '/workspaces/customization_profiles/update'(): (parameters?: WorkspacesCustomizationProfilesUpdateParameters, options?: WorkspacesCustomizationProfilesUpdateOptions) => WorkspacesCustomizationProfilesUpdateRequest;
    get '/workspaces/customization_profiles/upload_images'(): (parameters?: WorkspacesCustomizationProfilesUploadImagesParameters, options?: WorkspacesCustomizationProfilesUploadImagesOptions) => WorkspacesCustomizationProfilesUploadImagesRequest;
}
type SeamHttpEndpointQueryPaths = '/access_codes/generate_code' | '/access_codes/get' | '/access_codes/get_timeline' | '/access_codes/list' | '/access_codes/unmanaged/get' | '/access_codes/unmanaged/list' | '/access_grants/get' | '/access_grants/get_related' | '/access_grants/list' | '/access_grants/unmanaged/get' | '/access_grants/unmanaged/list' | '/access_methods/get' | '/access_methods/get_related' | '/access_methods/list' | '/access_methods/unmanaged/get' | '/access_methods/unmanaged/list' | '/acs/access_groups/get' | '/acs/access_groups/list' | '/acs/access_groups/list_accessible_entrances' | '/acs/access_groups/list_users' | '/acs/access_groups/unmanaged/get' | '/acs/access_groups/unmanaged/list' | '/acs/credential_pools/list' | '/acs/credentials/get' | '/acs/credentials/list' | '/acs/credentials/list_accessible_entrances' | '/acs/credentials/unmanaged/get' | '/acs/credentials/unmanaged/list' | '/acs/encoders/get' | '/acs/encoders/list' | '/acs/entrances/get' | '/acs/entrances/list' | '/acs/entrances/list_credentials_with_access' | '/acs/systems/get' | '/acs/systems/list' | '/acs/systems/list_compatible_credential_manager_acs_systems' | '/acs/users/get' | '/acs/users/list' | '/acs/users/list_accessible_entrances' | '/acs/users/unmanaged/get' | '/acs/users/unmanaged/list' | '/action_attempts/get' | '/action_attempts/list' | '/bridges/get' | '/bridges/list' | '/client_sessions/get' | '/client_sessions/list' | '/connect_webviews/get' | '/connect_webviews/list' | '/connected_accounts/get' | '/connected_accounts/list' | '/devices/get' | '/devices/list' | '/devices/list_device_providers' | '/devices/unmanaged/get' | '/devices/unmanaged/list' | '/events/get' | '/events/list' | '/instant_keys/get' | '/instant_keys/list' | '/locks/get' | '/locks/list' | '/noise_sensors/list' | '/noise_sensors/noise_thresholds/get' | '/noise_sensors/noise_thresholds/list' | '/phones/get' | '/phones/list' | '/seam/console/v1/get_resource_locator' | '/seam/console/v1/timelines/get' | '/seam/customer/v1/access_grants/list' | '/seam/customer/v1/automation_runs/list' | '/seam/customer/v1/automations/get' | '/seam/customer/v1/connector_customers/list' | '/seam/customer/v1/connectors/authorize' | '/seam/customer/v1/connectors/connector_types' | '/seam/customer/v1/connectors/list' | '/seam/customer/v1/customers/automations/get' | '/seam/customer/v1/customers/list' | '/seam/customer/v1/customers/me' | '/seam/customer/v1/encoders/list' | '/seam/customer/v1/events/list' | '/seam/customer/v1/portals/get' | '/seam/customer/v1/reservations/get' | '/seam/customer/v1/reservations/list' | '/seam/customer/v1/reservations/list_access_grants' | '/seam/customer/v1/settings/get' | '/seam/customer/v1/settings/vertical_resource_aliases/get' | '/seam/customer/v1/spaces/list' | '/seam/customer/v1/spaces/list_reservations' | '/seam/customer/v1/staff_members/get' | '/seam/customer/v1/staff_members/list' | '/seam/partner/v1/building_blocks/spaces/auto_map' | '/spaces/get' | '/spaces/get_related' | '/spaces/list' | '/thermostats/get' | '/thermostats/list' | '/thermostats/schedules/get' | '/thermostats/schedules/list' | '/unstable_partner/building_blocks/generate_magic_link' | '/user_identities/get' | '/user_identities/list' | '/user_identities/list_accessible_devices' | '/user_identities/list_accessible_entrances' | '/user_identities/list_acs_systems' | '/user_identities/list_acs_users' | '/user_identities/enrollment_automations/get' | '/user_identities/enrollment_automations/list' | '/user_identities/unmanaged/get' | '/user_identities/unmanaged/list' | '/webhooks/get' | '/webhooks/list' | '/workspaces/find_anything' | '/workspaces/get' | '/workspaces/list' | '/workspaces/customization_profiles/get' | '/workspaces/customization_profiles/list';
type SeamHttpEndpointPaginatedQueryPaths = '/access_codes/list' | '/access_codes/unmanaged/list' | '/access_grants/list' | '/access_grants/unmanaged/list' | '/acs/credentials/list' | '/acs/encoders/list' | '/acs/entrances/list' | '/acs/users/list' | '/action_attempts/list' | '/connect_webviews/list' | '/connected_accounts/list' | '/devices/list' | '/devices/unmanaged/list' | '/seam/customer/v1/automation_runs/list' | '/seam/customer/v1/customers/list' | '/seam/customer/v1/reservations/list' | '/seam/customer/v1/staff_members/list' | '/spaces/list' | '/user_identities/list' | '/user_identities/unmanaged/list';
type SeamHttpEndpointMutationPaths = '/access_codes/create' | '/access_codes/create_multiple' | '/access_codes/delete' | '/access_codes/pull_backup_access_code' | '/access_codes/report_device_constraints' | '/access_codes/update' | '/access_codes/update_multiple' | '/access_codes/simulate/create_unmanaged_access_code' | '/access_codes/unmanaged/convert_to_managed' | '/access_codes/unmanaged/delete' | '/access_codes/unmanaged/update' | '/access_grants/create' | '/access_grants/delete' | '/access_grants/request_access_methods' | '/access_grants/update' | '/access_grants/unmanaged/update' | '/access_methods/delete' | '/access_methods/encode' | '/acs/access_groups/add_user' | '/acs/access_groups/delete' | '/acs/access_groups/remove_user' | '/acs/credential_provisioning_automations/launch' | '/acs/credentials/assign' | '/acs/credentials/create' | '/acs/credentials/create_offline_code' | '/acs/credentials/delete' | '/acs/credentials/unassign' | '/acs/credentials/update' | '/acs/encoders/encode_credential' | '/acs/encoders/scan_credential' | '/acs/encoders/simulate/next_credential_encode_will_fail' | '/acs/encoders/simulate/next_credential_encode_will_succeed' | '/acs/encoders/simulate/next_credential_scan_will_fail' | '/acs/encoders/simulate/next_credential_scan_will_succeed' | '/acs/entrances/grant_access' | '/acs/entrances/unlock' | '/acs/systems/report_devices' | '/acs/users/add_to_access_group' | '/acs/users/create' | '/acs/users/delete' | '/acs/users/remove_from_access_group' | '/acs/users/revoke_access_to_all_entrances' | '/acs/users/suspend' | '/acs/users/unsuspend' | '/acs/users/update' | '/client_sessions/create' | '/client_sessions/delete' | '/client_sessions/get_or_create' | '/client_sessions/grant_access' | '/client_sessions/revoke' | '/connect_webviews/create' | '/connect_webviews/delete' | '/connected_accounts/delete' | '/connected_accounts/sync' | '/connected_accounts/update' | '/connected_accounts/simulate/disconnect' | '/customers/create_portal' | '/customers/delete_data' | '/customers/push_data' | '/customers/reservations/create_deep_link' | '/devices/delete' | '/devices/report_provider_metadata' | '/devices/update' | '/devices/simulate/connect' | '/devices/simulate/connect_to_hub' | '/devices/simulate/disconnect' | '/devices/simulate/disconnect_from_hub' | '/devices/simulate/paid_subscription' | '/devices/simulate/remove' | '/devices/unmanaged/update' | '/instant_keys/delete' | '/locks/configure_auto_lock' | '/locks/lock_door' | '/locks/unlock_door' | '/locks/simulate/keypad_code_entry' | '/locks/simulate/manual_lock_via_keypad' | '/noise_sensors/noise_thresholds/create' | '/noise_sensors/noise_thresholds/delete' | '/noise_sensors/noise_thresholds/update' | '/noise_sensors/simulate/trigger_noise_threshold' | '/phones/deactivate' | '/phones/simulate/create_sandbox_phone' | '/seam/customer/v1/access_grants/update' | '/seam/customer/v1/access_methods/encode' | '/seam/customer/v1/automations/delete' | '/seam/customer/v1/automations/update' | '/seam/customer/v1/connectors/create' | '/seam/customer/v1/connectors/delete' | '/seam/customer/v1/connectors/sync' | '/seam/customer/v1/connectors/update' | '/seam/customer/v1/connectors/ical/validate-config' | '/seam/customer/v1/customers/automations/update' | '/seam/customer/v1/customers/open_portal' | '/seam/customer/v1/portals/update' | '/seam/customer/v1/settings/update' | '/seam/customer/v1/spaces/create' | '/seam/customer/v1/spaces/push_common_areas' | '/spaces/add_acs_entrances' | '/spaces/add_connected_account' | '/spaces/add_devices' | '/spaces/create' | '/spaces/delete' | '/spaces/remove_acs_entrances' | '/spaces/remove_connected_account' | '/spaces/remove_devices' | '/spaces/update' | '/thermostats/activate_climate_preset' | '/thermostats/cool' | '/thermostats/create_climate_preset' | '/thermostats/delete_climate_preset' | '/thermostats/heat' | '/thermostats/heat_cool' | '/thermostats/off' | '/thermostats/set_fallback_climate_preset' | '/thermostats/set_fan_mode' | '/thermostats/set_hvac_mode' | '/thermostats/set_temperature_threshold' | '/thermostats/update_climate_preset' | '/thermostats/update_weekly_program' | '/thermostats/daily_programs/create' | '/thermostats/daily_programs/delete' | '/thermostats/daily_programs/update' | '/thermostats/schedules/create' | '/thermostats/schedules/delete' | '/thermostats/schedules/update' | '/thermostats/simulate/hvac_mode_adjusted' | '/thermostats/simulate/temperature_reached' | '/unstable_partner/building_blocks/connect_accounts' | '/unstable_partner/building_blocks/manage_devices' | '/unstable_partner/building_blocks/organize_spaces' | '/user_identities/add_acs_user' | '/user_identities/create' | '/user_identities/delete' | '/user_identities/generate_instant_key' | '/user_identities/grant_access_to_device' | '/user_identities/remove_acs_user' | '/user_identities/revoke_access_to_device' | '/user_identities/update' | '/user_identities/enrollment_automations/delete' | '/user_identities/enrollment_automations/launch' | '/user_identities/unmanaged/update' | '/webhooks/create' | '/webhooks/delete' | '/webhooks/update' | '/workspaces/create' | '/workspaces/reset_sandbox' | '/workspaces/update' | '/workspaces/customization_profiles/create' | '/workspaces/customization_profiles/update' | '/workspaces/customization_profiles/upload_images';

declare class SeamHttpEndpointsWithoutWorkspace {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(options?: SeamHttpWithoutWorkspaceOptions);
    static fromClient(client: SeamHttpWithoutWorkspaceOptionsWithClient['client'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithClient, 'client'>): SeamHttpEndpointsWithoutWorkspace;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken['consoleSessionToken'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken, 'consoleSessionToken'>): SeamHttpEndpointsWithoutWorkspace;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken['personalAccessToken'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken, 'personalAccessToken'>): SeamHttpEndpointsWithoutWorkspace;
    get '/seam/customer/v1/connectors/authorize'(): (parameters?: SeamCustomerV1ConnectorsAuthorizeParameters, options?: SeamCustomerV1ConnectorsAuthorizeOptions) => SeamCustomerV1ConnectorsAuthorizeRequest;
    get '/workspaces/create'(): (parameters?: WorkspacesCreateParameters, options?: WorkspacesCreateOptions) => WorkspacesCreateRequest;
    get '/workspaces/list'(): (parameters?: WorkspacesListParameters, options?: WorkspacesListOptions) => WorkspacesListRequest;
}
type SeamHttpEndpointWithoutWorkspaceQueryPaths = '/seam/customer/v1/connectors/authorize' | '/workspaces/list';
type SeamHttpEndpointWithoutWorkspaceMutationPaths = '/workspaces/create';

declare class SeamHttpWithoutWorkspace {
    client: Client;
    readonly defaults: Required<SeamHttpRequestOptions>;
    readonly ltsVersion = "1.0.0";
    static ltsVersion: string;
    constructor(options?: SeamHttpWithoutWorkspaceOptions);
    static fromClient(client: SeamHttpWithoutWorkspaceOptionsWithClient['client'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithClient, 'client'>): SeamHttpWithoutWorkspace;
    static fromConsoleSessionToken(consoleSessionToken: SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken['consoleSessionToken'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken, 'consoleSessionToken'>): SeamHttpWithoutWorkspace;
    static fromPersonalAccessToken(personalAccessToken: SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken['personalAccessToken'], options?: Omit<SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken, 'personalAccessToken'>): SeamHttpWithoutWorkspace;
    get workspaces(): Pick<SeamHttpWorkspaces, 'create' | 'list'>;
}
/**
 * @deprecated Use SeamHttpWithoutWorkspace instead.
 */
declare const SeamHttpMultiWorkspace: typeof SeamHttpWithoutWorkspace;

interface ResolveActionAttemptOptions {
    timeout?: number;
    pollingInterval?: number;
}
declare const isSeamActionAttemptError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptError<T>;
declare class SeamActionAttemptError<T extends ActionAttempt> extends Error {
    actionAttempt: T;
    constructor(message: string, actionAttempt: T);
}
declare const isSeamActionAttemptFailedError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptFailedError<T>;
declare class SeamActionAttemptFailedError<T extends ActionAttempt> extends SeamActionAttemptError<T> {
    code: string;
    constructor(actionAttempt: FailedActionAttempt<T>);
}
declare const isSeamActionAttemptTimeoutError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptTimeoutError<T>;
declare class SeamActionAttemptTimeoutError<T extends ActionAttempt> extends SeamActionAttemptError<T> {
    constructor(actionAttempt: T, timeout: number);
}
type FailedActionAttempt<T extends ActionAttempt> = Extract<T, {
    status: 'error';
}>;

type SeamHttpWithoutWorkspaceOptions = SeamHttpWithoutWorkspaceOptionsFromEnv | SeamHttpWithoutWorkspaceOptionsWithClient | SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken | SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken;
type SeamHttpOptions = SeamHttpOptionsFromEnv | SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken | SeamHttpOptionsWithConsoleSessionToken | SeamHttpOptionsWithPersonalAccessToken;
interface SeamHttpCommonOptions extends ClientOptions, SeamHttpRequestOptions {
    endpoint?: string;
}
interface SeamHttpRequestOptions {
    waitForActionAttempt?: boolean | ResolveActionAttemptOptions;
    isUndocumentedApiEnabled?: boolean;
}
interface SeamHttpFromPublishableKeyOptions extends SeamHttpCommonOptions {
}
interface SeamHttpOptionsFromEnv extends SeamHttpCommonOptions {
}
interface SeamHttpWithoutWorkspaceOptionsFromEnv extends SeamHttpCommonOptions {
}
interface SeamHttpWithoutWorkspaceOptionsWithClient extends SeamHttpCommonOptions {
    client: Client;
}
declare const isSeamHttpWithoutWorkspaceOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpWithoutWorkspaceOptionsWithClient;
interface SeamHttpOptionsWithClient extends SeamHttpRequestOptions {
    client: Client;
}
declare const isSeamHttpOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClient;
interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
    apiKey: string;
}
declare const isSeamHttpOptionsWithApiKey: (options: SeamHttpOptions) => options is SeamHttpOptionsWithApiKey;
interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOptions {
    clientSessionToken: string;
}
declare const isSeamHttpOptionsWithClientSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClientSessionToken;
interface SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
    consoleSessionToken: string;
}
declare const isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken: (options: SeamHttpOptions) => options is SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken;
interface SeamHttpOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
    consoleSessionToken: string;
    workspaceId: string;
}
declare const isSeamHttpOptionsWithConsoleSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithConsoleSessionToken;
interface SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
    personalAccessToken: string;
}
declare const isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken: (options: SeamHttpOptions) => options is SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken;
interface SeamHttpOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
    personalAccessToken: string;
    workspaceId: string;
}
declare const isSeamHttpOptionsWithPersonalAccessToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithPersonalAccessToken;
declare class SeamHttpInvalidOptionsError extends Error {
    constructor(message: string);
}
declare class SeamHttpWithoutWorkspaceInvalidOptionsError extends Error {
    constructor(message: string);
}

declare class SeamHttpInvalidTokenError extends Error {
    constructor(message: string);
}

declare const errorInterceptor: (err: unknown) => Promise<void>;

declare const getOpenapiSchema: (endpoint?: string) => Promise<typeof openapi>;

interface ApiError {
    type: string;
    message: string;
    data?: unknown;
    validation_errors?: Record<string, {
        _errors: string[];
    }>;
}

declare class SeamHttpApiError extends Error {
    code: string;
    statusCode: number;
    requestId: string;
    data?: unknown;
    constructor(error: ApiError, statusCode: number, requestId: string);
}
declare const isSeamHttpApiError: (error: unknown) => error is SeamHttpApiError;
declare class SeamHttpUnauthorizedError extends SeamHttpApiError {
    code: 'unauthorized';
    statusCode: 401;
    constructor(requestId: string);
}
declare const isSeamHttpUnauthorizedError: (error: unknown) => error is SeamHttpUnauthorizedError;
declare class SeamHttpInvalidInputError extends SeamHttpApiError {
    #private;
    code: 'invalid_input';
    constructor(error: ApiError, statusCode: number, requestId: string);
    getValidationErrorMessages(paramName: string): string[];
}
declare const isSeamHttpInvalidInputError: (error: unknown) => error is SeamHttpInvalidInputError;

declare const isApiKey: (token: string) => boolean;
declare const isClientSessionToken: (token: string) => boolean;
declare const isPublishableKey: (token: string) => boolean;
declare const isConsoleSessionToken: (token: string) => boolean;
declare const isPersonalAccessToken: (token: string) => boolean;

export { type AccessCodesCreateBody, type AccessCodesCreateMultipleBody, type AccessCodesCreateMultipleOptions, type AccessCodesCreateMultipleParameters, type AccessCodesCreateMultipleRequest, type AccessCodesCreateMultipleResponse, type AccessCodesCreateOptions, type AccessCodesCreateParameters, type AccessCodesCreateRequest, type AccessCodesCreateResponse, type AccessCodesDeleteOptions, type AccessCodesDeleteParameters, type AccessCodesDeleteParams, type AccessCodesDeleteRequest, type AccessCodesDeleteResponse, type AccessCodesGenerateCodeOptions, type AccessCodesGenerateCodeParameters, type AccessCodesGenerateCodeParams, type AccessCodesGenerateCodeRequest, type AccessCodesGenerateCodeResponse, type AccessCodesGetOptions, type AccessCodesGetParameters, type AccessCodesGetParams, type AccessCodesGetRequest, type AccessCodesGetResponse, type AccessCodesGetTimelineOptions, type AccessCodesGetTimelineParameters, type AccessCodesGetTimelineParams, type AccessCodesGetTimelineRequest, type AccessCodesGetTimelineResponse, type AccessCodesListOptions, type AccessCodesListParameters, type AccessCodesListParams, type AccessCodesListRequest, type AccessCodesListResponse, type AccessCodesPullBackupAccessCodeBody, type AccessCodesPullBackupAccessCodeOptions, type AccessCodesPullBackupAccessCodeParameters, type AccessCodesPullBackupAccessCodeRequest, type AccessCodesPullBackupAccessCodeResponse, type AccessCodesReportDeviceConstraintsBody, type AccessCodesReportDeviceConstraintsOptions, type AccessCodesReportDeviceConstraintsParameters, type AccessCodesReportDeviceConstraintsRequest, type AccessCodesReportDeviceConstraintsResponse, type AccessCodesSimulateCreateUnmanagedAccessCodeBody, type AccessCodesSimulateCreateUnmanagedAccessCodeOptions, type AccessCodesSimulateCreateUnmanagedAccessCodeParameters, type AccessCodesSimulateCreateUnmanagedAccessCodeRequest, type AccessCodesSimulateCreateUnmanagedAccessCodeResponse, type AccessCodesUnmanagedConvertToManagedBody, type AccessCodesUnmanagedConvertToManagedOptions, type AccessCodesUnmanagedConvertToManagedParameters, type AccessCodesUnmanagedConvertToManagedRequest, type AccessCodesUnmanagedConvertToManagedResponse, type AccessCodesUnmanagedDeleteOptions, type AccessCodesUnmanagedDeleteParameters, type AccessCodesUnmanagedDeleteParams, type AccessCodesUnmanagedDeleteRequest, type AccessCodesUnmanagedDeleteResponse, type AccessCodesUnmanagedGetOptions, type AccessCodesUnmanagedGetParameters, type AccessCodesUnmanagedGetParams, type AccessCodesUnmanagedGetRequest, type AccessCodesUnmanagedGetResponse, type AccessCodesUnmanagedListOptions, type AccessCodesUnmanagedListParameters, type AccessCodesUnmanagedListParams, type AccessCodesUnmanagedListRequest, type AccessCodesUnmanagedListResponse, type AccessCodesUnmanagedUpdateBody, type AccessCodesUnmanagedUpdateOptions, type AccessCodesUnmanagedUpdateParameters, type AccessCodesUnmanagedUpdateRequest, type AccessCodesUnmanagedUpdateResponse, type AccessCodesUpdateBody, type AccessCodesUpdateMultipleBody, type AccessCodesUpdateMultipleOptions, type AccessCodesUpdateMultipleParameters, type AccessCodesUpdateMultipleRequest, type AccessCodesUpdateMultipleResponse, type AccessCodesUpdateOptions, type AccessCodesUpdateParameters, type AccessCodesUpdateRequest, type AccessCodesUpdateResponse, type AccessGrantsCreateBody, type AccessGrantsCreateOptions, type AccessGrantsCreateParameters, type AccessGrantsCreateRequest, type AccessGrantsCreateResponse, type AccessGrantsDeleteOptions, type AccessGrantsDeleteParameters, type AccessGrantsDeleteParams, type AccessGrantsDeleteRequest, type AccessGrantsDeleteResponse, type AccessGrantsGetOptions, type AccessGrantsGetParameters, type AccessGrantsGetParams, type AccessGrantsGetRelatedOptions, type AccessGrantsGetRelatedParameters, type AccessGrantsGetRelatedParams, type AccessGrantsGetRelatedRequest, type AccessGrantsGetRelatedResponse, type AccessGrantsGetRequest, type AccessGrantsGetResponse, type AccessGrantsListOptions, type AccessGrantsListParameters, type AccessGrantsListParams, type AccessGrantsListRequest, type AccessGrantsListResponse, type AccessGrantsRequestAccessMethodsBody, type AccessGrantsRequestAccessMethodsOptions, type AccessGrantsRequestAccessMethodsParameters, type AccessGrantsRequestAccessMethodsRequest, type AccessGrantsRequestAccessMethodsResponse, type AccessGrantsUnmanagedGetOptions, type AccessGrantsUnmanagedGetParameters, type AccessGrantsUnmanagedGetParams, type AccessGrantsUnmanagedGetRequest, type AccessGrantsUnmanagedGetResponse, type AccessGrantsUnmanagedListOptions, type AccessGrantsUnmanagedListParameters, type AccessGrantsUnmanagedListParams, type AccessGrantsUnmanagedListRequest, type AccessGrantsUnmanagedListResponse, type AccessGrantsUnmanagedUpdateBody, type AccessGrantsUnmanagedUpdateOptions, type AccessGrantsUnmanagedUpdateParameters, type AccessGrantsUnmanagedUpdateRequest, type AccessGrantsUnmanagedUpdateResponse, type AccessGrantsUpdateBody, type AccessGrantsUpdateOptions, type AccessGrantsUpdateParameters, type AccessGrantsUpdateRequest, type AccessGrantsUpdateResponse, type AccessMethodsDeleteOptions, type AccessMethodsDeleteParameters, type AccessMethodsDeleteParams, type AccessMethodsDeleteRequest, type AccessMethodsDeleteResponse, type AccessMethodsEncodeBody, type AccessMethodsEncodeOptions, type AccessMethodsEncodeParameters, type AccessMethodsEncodeRequest, type AccessMethodsEncodeResponse, type AccessMethodsGetOptions, type AccessMethodsGetParameters, type AccessMethodsGetParams, type AccessMethodsGetRelatedOptions, type AccessMethodsGetRelatedParameters, type AccessMethodsGetRelatedParams, type AccessMethodsGetRelatedRequest, type AccessMethodsGetRelatedResponse, type AccessMethodsGetRequest, type AccessMethodsGetResponse, type AccessMethodsListOptions, type AccessMethodsListParameters, type AccessMethodsListParams, type AccessMethodsListRequest, type AccessMethodsListResponse, type AccessMethodsUnmanagedGetOptions, type AccessMethodsUnmanagedGetParameters, type AccessMethodsUnmanagedGetParams, type AccessMethodsUnmanagedGetRequest, type AccessMethodsUnmanagedGetResponse, type AccessMethodsUnmanagedListOptions, type AccessMethodsUnmanagedListParameters, type AccessMethodsUnmanagedListParams, type AccessMethodsUnmanagedListRequest, type AccessMethodsUnmanagedListResponse, type AcsAccessGroupsAddUserBody, type AcsAccessGroupsAddUserOptions, type AcsAccessGroupsAddUserParameters, type AcsAccessGroupsAddUserRequest, type AcsAccessGroupsAddUserResponse, type AcsAccessGroupsDeleteOptions, type AcsAccessGroupsDeleteParameters, type AcsAccessGroupsDeleteParams, type AcsAccessGroupsDeleteRequest, type AcsAccessGroupsDeleteResponse, type AcsAccessGroupsGetOptions, type AcsAccessGroupsGetParameters, type AcsAccessGroupsGetParams, type AcsAccessGroupsGetRequest, type AcsAccessGroupsGetResponse, type AcsAccessGroupsListAccessibleEntrancesOptions, type AcsAccessGroupsListAccessibleEntrancesParameters, type AcsAccessGroupsListAccessibleEntrancesParams, type AcsAccessGroupsListAccessibleEntrancesRequest, type AcsAccessGroupsListAccessibleEntrancesResponse, type AcsAccessGroupsListOptions, type AcsAccessGroupsListParameters, type AcsAccessGroupsListParams, type AcsAccessGroupsListRequest, type AcsAccessGroupsListResponse, type AcsAccessGroupsListUsersOptions, type AcsAccessGroupsListUsersParameters, type AcsAccessGroupsListUsersParams, type AcsAccessGroupsListUsersRequest, type AcsAccessGroupsListUsersResponse, type AcsAccessGroupsRemoveUserOptions, type AcsAccessGroupsRemoveUserParameters, type AcsAccessGroupsRemoveUserParams, type AcsAccessGroupsRemoveUserRequest, type AcsAccessGroupsRemoveUserResponse, type AcsAccessGroupsUnmanagedGetOptions, type AcsAccessGroupsUnmanagedGetParameters, type AcsAccessGroupsUnmanagedGetParams, type AcsAccessGroupsUnmanagedGetRequest, type AcsAccessGroupsUnmanagedGetResponse, type AcsAccessGroupsUnmanagedListOptions, type AcsAccessGroupsUnmanagedListParameters, type AcsAccessGroupsUnmanagedListParams, type AcsAccessGroupsUnmanagedListRequest, type AcsAccessGroupsUnmanagedListResponse, type AcsCredentialPoolsListOptions, type AcsCredentialPoolsListParameters, type AcsCredentialPoolsListParams, type AcsCredentialPoolsListRequest, type AcsCredentialPoolsListResponse, type AcsCredentialProvisioningAutomationsLaunchBody, type AcsCredentialProvisioningAutomationsLaunchOptions, type AcsCredentialProvisioningAutomationsLaunchParameters, type AcsCredentialProvisioningAutomationsLaunchRequest, type AcsCredentialProvisioningAutomationsLaunchResponse, type AcsCredentialsAssignBody, type AcsCredentialsAssignOptions, type AcsCredentialsAssignParameters, type AcsCredentialsAssignRequest, type AcsCredentialsAssignResponse, type AcsCredentialsCreateBody, type AcsCredentialsCreateOfflineCodeBody, type AcsCredentialsCreateOfflineCodeOptions, type AcsCredentialsCreateOfflineCodeParameters, type AcsCredentialsCreateOfflineCodeRequest, type AcsCredentialsCreateOfflineCodeResponse, type AcsCredentialsCreateOptions, type AcsCredentialsCreateParameters, type AcsCredentialsCreateRequest, type AcsCredentialsCreateResponse, type AcsCredentialsDeleteOptions, type AcsCredentialsDeleteParameters, type AcsCredentialsDeleteParams, type AcsCredentialsDeleteRequest, type AcsCredentialsDeleteResponse, type AcsCredentialsGetOptions, type AcsCredentialsGetParameters, type AcsCredentialsGetParams, type AcsCredentialsGetRequest, type AcsCredentialsGetResponse, type AcsCredentialsListAccessibleEntrancesOptions, type AcsCredentialsListAccessibleEntrancesParameters, type AcsCredentialsListAccessibleEntrancesParams, type AcsCredentialsListAccessibleEntrancesRequest, type AcsCredentialsListAccessibleEntrancesResponse, type AcsCredentialsListOptions, type AcsCredentialsListParameters, type AcsCredentialsListParams, type AcsCredentialsListRequest, type AcsCredentialsListResponse, type AcsCredentialsUnassignBody, type AcsCredentialsUnassignOptions, type AcsCredentialsUnassignParameters, type AcsCredentialsUnassignRequest, type AcsCredentialsUnassignResponse, type AcsCredentialsUnmanagedGetOptions, type AcsCredentialsUnmanagedGetParameters, type AcsCredentialsUnmanagedGetParams, type AcsCredentialsUnmanagedGetRequest, type AcsCredentialsUnmanagedGetResponse, type AcsCredentialsUnmanagedListOptions, type AcsCredentialsUnmanagedListParameters, type AcsCredentialsUnmanagedListParams, type AcsCredentialsUnmanagedListRequest, type AcsCredentialsUnmanagedListResponse, type AcsCredentialsUpdateBody, type AcsCredentialsUpdateOptions, type AcsCredentialsUpdateParameters, type AcsCredentialsUpdateRequest, type AcsCredentialsUpdateResponse, type AcsEncodersEncodeCredentialBody, type AcsEncodersEncodeCredentialOptions, type AcsEncodersEncodeCredentialParameters, type AcsEncodersEncodeCredentialRequest, type AcsEncodersEncodeCredentialResponse, type AcsEncodersGetOptions, type AcsEncodersGetParameters, type AcsEncodersGetParams, type AcsEncodersGetRequest, type AcsEncodersGetResponse, type AcsEncodersListOptions, type AcsEncodersListParameters, type AcsEncodersListParams, type AcsEncodersListRequest, type AcsEncodersListResponse, type AcsEncodersScanCredentialBody, type AcsEncodersScanCredentialOptions, type AcsEncodersScanCredentialParameters, type AcsEncodersScanCredentialRequest, type AcsEncodersScanCredentialResponse, type AcsEncodersSimulateNextCredentialEncodeWillFailBody, type AcsEncodersSimulateNextCredentialEncodeWillFailOptions, type AcsEncodersSimulateNextCredentialEncodeWillFailParameters, type AcsEncodersSimulateNextCredentialEncodeWillFailRequest, type AcsEncodersSimulateNextCredentialEncodeWillFailResponse, type AcsEncodersSimulateNextCredentialEncodeWillSucceedBody, type AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions, type AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters, type AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest, type AcsEncodersSimulateNextCredentialEncodeWillSucceedResponse, type AcsEncodersSimulateNextCredentialScanWillFailBody, type AcsEncodersSimulateNextCredentialScanWillFailOptions, type AcsEncodersSimulateNextCredentialScanWillFailParameters, type AcsEncodersSimulateNextCredentialScanWillFailRequest, type AcsEncodersSimulateNextCredentialScanWillFailResponse, type AcsEncodersSimulateNextCredentialScanWillSucceedBody, type AcsEncodersSimulateNextCredentialScanWillSucceedOptions, type AcsEncodersSimulateNextCredentialScanWillSucceedParameters, type AcsEncodersSimulateNextCredentialScanWillSucceedRequest, type AcsEncodersSimulateNextCredentialScanWillSucceedResponse, type AcsEntrancesGetOptions, type AcsEntrancesGetParameters, type AcsEntrancesGetParams, type AcsEntrancesGetRequest, type AcsEntrancesGetResponse, type AcsEntrancesGrantAccessBody, type AcsEntrancesGrantAccessOptions, type AcsEntrancesGrantAccessParameters, type AcsEntrancesGrantAccessRequest, type AcsEntrancesGrantAccessResponse, type AcsEntrancesListCredentialsWithAccessOptions, type AcsEntrancesListCredentialsWithAccessParameters, type AcsEntrancesListCredentialsWithAccessParams, type AcsEntrancesListCredentialsWithAccessRequest, type AcsEntrancesListCredentialsWithAccessResponse, type AcsEntrancesListOptions, type AcsEntrancesListParameters, type AcsEntrancesListParams, type AcsEntrancesListRequest, type AcsEntrancesListResponse, type AcsEntrancesUnlockBody, type AcsEntrancesUnlockOptions, type AcsEntrancesUnlockParameters, type AcsEntrancesUnlockRequest, type AcsEntrancesUnlockResponse, type AcsSystemsGetOptions, type AcsSystemsGetParameters, type AcsSystemsGetParams, type AcsSystemsGetRequest, type AcsSystemsGetResponse, type AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions, type AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters, type AcsSystemsListCompatibleCredentialManagerAcsSystemsParams, type AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest, type AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse, type AcsSystemsListOptions, type AcsSystemsListParameters, type AcsSystemsListParams, type AcsSystemsListRequest, type AcsSystemsListResponse, type AcsSystemsReportDevicesBody, type AcsSystemsReportDevicesOptions, type AcsSystemsReportDevicesParameters, type AcsSystemsReportDevicesRequest, type AcsSystemsReportDevicesResponse, type AcsUsersAddToAccessGroupBody, type AcsUsersAddToAccessGroupOptions, type AcsUsersAddToAccessGroupParameters, type AcsUsersAddToAccessGroupRequest, type AcsUsersAddToAccessGroupResponse, type AcsUsersCreateBody, type AcsUsersCreateOptions, type AcsUsersCreateParameters, type AcsUsersCreateRequest, type AcsUsersCreateResponse, type AcsUsersDeleteOptions, type AcsUsersDeleteParameters, type AcsUsersDeleteParams, type AcsUsersDeleteRequest, type AcsUsersDeleteResponse, type AcsUsersGetOptions, type AcsUsersGetParameters, type AcsUsersGetParams, type AcsUsersGetRequest, type AcsUsersGetResponse, type AcsUsersListAccessibleEntrancesOptions, type AcsUsersListAccessibleEntrancesParameters, type AcsUsersListAccessibleEntrancesParams, type AcsUsersListAccessibleEntrancesRequest, type AcsUsersListAccessibleEntrancesResponse, type AcsUsersListOptions, type AcsUsersListParameters, type AcsUsersListParams, type AcsUsersListRequest, type AcsUsersListResponse, type AcsUsersRemoveFromAccessGroupOptions, type AcsUsersRemoveFromAccessGroupParameters, type AcsUsersRemoveFromAccessGroupParams, type AcsUsersRemoveFromAccessGroupRequest, type AcsUsersRemoveFromAccessGroupResponse, type AcsUsersRevokeAccessToAllEntrancesBody, type AcsUsersRevokeAccessToAllEntrancesOptions, type AcsUsersRevokeAccessToAllEntrancesParameters, type AcsUsersRevokeAccessToAllEntrancesRequest, type AcsUsersRevokeAccessToAllEntrancesResponse, type AcsUsersSuspendBody, type AcsUsersSuspendOptions, type AcsUsersSuspendParameters, type AcsUsersSuspendRequest, type AcsUsersSuspendResponse, type AcsUsersUnmanagedGetOptions, type AcsUsersUnmanagedGetParameters, type AcsUsersUnmanagedGetParams, type AcsUsersUnmanagedGetRequest, type AcsUsersUnmanagedGetResponse, type AcsUsersUnmanagedListOptions, type AcsUsersUnmanagedListParameters, type AcsUsersUnmanagedListParams, type AcsUsersUnmanagedListRequest, type AcsUsersUnmanagedListResponse, type AcsUsersUnsuspendBody, type AcsUsersUnsuspendOptions, type AcsUsersUnsuspendParameters, type AcsUsersUnsuspendRequest, type AcsUsersUnsuspendResponse, type AcsUsersUpdateBody, type AcsUsersUpdateOptions, type AcsUsersUpdateParameters, type AcsUsersUpdateRequest, type AcsUsersUpdateResponse, type ActionAttemptsGetOptions, type ActionAttemptsGetParameters, type ActionAttemptsGetParams, type ActionAttemptsGetRequest, type ActionAttemptsGetResponse, type ActionAttemptsListOptions, type ActionAttemptsListParameters, type ActionAttemptsListParams, type ActionAttemptsListRequest, type ActionAttemptsListResponse, type BridgesGetOptions, type BridgesGetParameters, type BridgesGetParams, type BridgesGetRequest, type BridgesGetResponse, type BridgesListOptions, type BridgesListParameters, type BridgesListParams, type BridgesListRequest, type BridgesListResponse, type ClientSessionsCreateBody, type ClientSessionsCreateOptions, type ClientSessionsCreateParameters, type ClientSessionsCreateRequest, type ClientSessionsCreateResponse, type ClientSessionsDeleteOptions, type ClientSessionsDeleteParameters, type ClientSessionsDeleteParams, type ClientSessionsDeleteRequest, type ClientSessionsDeleteResponse, type ClientSessionsGetOptions, type ClientSessionsGetOrCreateBody, type ClientSessionsGetOrCreateOptions, type ClientSessionsGetOrCreateParameters, type ClientSessionsGetOrCreateRequest, type ClientSessionsGetOrCreateResponse, type ClientSessionsGetParameters, type ClientSessionsGetParams, type ClientSessionsGetRequest, type ClientSessionsGetResponse, type ClientSessionsGrantAccessBody, type ClientSessionsGrantAccessOptions, type ClientSessionsGrantAccessParameters, type ClientSessionsGrantAccessRequest, type ClientSessionsGrantAccessResponse, type ClientSessionsListOptions, type ClientSessionsListParameters, type ClientSessionsListParams, type ClientSessionsListRequest, type ClientSessionsListResponse, type ClientSessionsRevokeBody, type ClientSessionsRevokeOptions, type ClientSessionsRevokeParameters, type ClientSessionsRevokeRequest, type ClientSessionsRevokeResponse, type ConnectWebviewsCreateBody, type ConnectWebviewsCreateOptions, type ConnectWebviewsCreateParameters, type ConnectWebviewsCreateRequest, type ConnectWebviewsCreateResponse, type ConnectWebviewsDeleteOptions, type ConnectWebviewsDeleteParameters, type ConnectWebviewsDeleteParams, type ConnectWebviewsDeleteRequest, type ConnectWebviewsDeleteResponse, type ConnectWebviewsGetOptions, type ConnectWebviewsGetParameters, type ConnectWebviewsGetParams, type ConnectWebviewsGetRequest, type ConnectWebviewsGetResponse, type ConnectWebviewsListOptions, type ConnectWebviewsListParameters, type ConnectWebviewsListParams, type ConnectWebviewsListRequest, type ConnectWebviewsListResponse, type ConnectedAccountsDeleteOptions, type ConnectedAccountsDeleteParameters, type ConnectedAccountsDeleteParams, type ConnectedAccountsDeleteRequest, type ConnectedAccountsDeleteResponse, type ConnectedAccountsGetOptions, type ConnectedAccountsGetParameters, type ConnectedAccountsGetParams, type ConnectedAccountsGetRequest, type ConnectedAccountsGetResponse, type ConnectedAccountsListOptions, type ConnectedAccountsListParameters, type ConnectedAccountsListParams, type ConnectedAccountsListRequest, type ConnectedAccountsListResponse, type ConnectedAccountsSimulateDisconnectBody, type ConnectedAccountsSimulateDisconnectOptions, type ConnectedAccountsSimulateDisconnectParameters, type ConnectedAccountsSimulateDisconnectRequest, type ConnectedAccountsSimulateDisconnectResponse, type ConnectedAccountsSyncBody, type ConnectedAccountsSyncOptions, type ConnectedAccountsSyncParameters, type ConnectedAccountsSyncRequest, type ConnectedAccountsSyncResponse, type ConnectedAccountsUpdateBody, type ConnectedAccountsUpdateOptions, type ConnectedAccountsUpdateParameters, type ConnectedAccountsUpdateRequest, type ConnectedAccountsUpdateResponse, type CustomersCreatePortalBody, type CustomersCreatePortalOptions, type CustomersCreatePortalParameters, type CustomersCreatePortalRequest, type CustomersCreatePortalResponse, type CustomersDeleteDataOptions, type CustomersDeleteDataParameters, type CustomersDeleteDataParams, type CustomersDeleteDataRequest, type CustomersDeleteDataResponse, type CustomersPushDataBody, type CustomersPushDataOptions, type CustomersPushDataParameters, type CustomersPushDataRequest, type CustomersPushDataResponse, type CustomersReservationsCreateDeepLinkBody, type CustomersReservationsCreateDeepLinkOptions, type CustomersReservationsCreateDeepLinkParameters, type CustomersReservationsCreateDeepLinkRequest, type CustomersReservationsCreateDeepLinkResponse, type DevicesDeleteOptions, type DevicesDeleteParameters, type DevicesDeleteParams, type DevicesDeleteRequest, type DevicesDeleteResponse, type DevicesGetOptions, type DevicesGetParameters, type DevicesGetParams, type DevicesGetRequest, type DevicesGetResponse, type DevicesListDeviceProvidersOptions, type DevicesListDeviceProvidersParameters, type DevicesListDeviceProvidersParams, type DevicesListDeviceProvidersRequest, type DevicesListDeviceProvidersResponse, type DevicesListOptions, type DevicesListParameters, type DevicesListParams, type DevicesListRequest, type DevicesListResponse, type DevicesReportProviderMetadataBody, type DevicesReportProviderMetadataOptions, type DevicesReportProviderMetadataParameters, type DevicesReportProviderMetadataRequest, type DevicesReportProviderMetadataResponse, type DevicesSimulateConnectBody, type DevicesSimulateConnectOptions, type DevicesSimulateConnectParameters, type DevicesSimulateConnectRequest, type DevicesSimulateConnectResponse, type DevicesSimulateConnectToHubBody, type DevicesSimulateConnectToHubOptions, type DevicesSimulateConnectToHubParameters, type DevicesSimulateConnectToHubRequest, type DevicesSimulateConnectToHubResponse, type DevicesSimulateDisconnectBody, type DevicesSimulateDisconnectFromHubBody, type DevicesSimulateDisconnectFromHubOptions, type DevicesSimulateDisconnectFromHubParameters, type DevicesSimulateDisconnectFromHubRequest, type DevicesSimulateDisconnectFromHubResponse, type DevicesSimulateDisconnectOptions, type DevicesSimulateDisconnectParameters, type DevicesSimulateDisconnectRequest, type DevicesSimulateDisconnectResponse, type DevicesSimulatePaidSubscriptionBody, type DevicesSimulatePaidSubscriptionOptions, type DevicesSimulatePaidSubscriptionParameters, type DevicesSimulatePaidSubscriptionRequest, type DevicesSimulatePaidSubscriptionResponse, type DevicesSimulateRemoveBody, type DevicesSimulateRemoveOptions, type DevicesSimulateRemoveParameters, type DevicesSimulateRemoveRequest, type DevicesSimulateRemoveResponse, type DevicesUnmanagedGetOptions, type DevicesUnmanagedGetParameters, type DevicesUnmanagedGetParams, type DevicesUnmanagedGetRequest, type DevicesUnmanagedGetResponse, type DevicesUnmanagedListOptions, type DevicesUnmanagedListParameters, type DevicesUnmanagedListParams, type DevicesUnmanagedListRequest, type DevicesUnmanagedListResponse, type DevicesUnmanagedUpdateBody, type DevicesUnmanagedUpdateOptions, type DevicesUnmanagedUpdateParameters, type DevicesUnmanagedUpdateRequest, type DevicesUnmanagedUpdateResponse, type DevicesUpdateBody, type DevicesUpdateOptions, type DevicesUpdateParameters, type DevicesUpdateRequest, type DevicesUpdateResponse, type EventsGetOptions, type EventsGetParameters, type EventsGetParams, type EventsGetRequest, type EventsGetResponse, type EventsListOptions, type EventsListParameters, type EventsListParams, type EventsListRequest, type EventsListResponse, type InstantKeysDeleteOptions, type InstantKeysDeleteParameters, type InstantKeysDeleteParams, type InstantKeysDeleteRequest, type InstantKeysDeleteResponse, type InstantKeysGetOptions, type InstantKeysGetParameters, type InstantKeysGetParams, type InstantKeysGetRequest, type InstantKeysGetResponse, type InstantKeysListOptions, type InstantKeysListParameters, type InstantKeysListParams, type InstantKeysListRequest, type InstantKeysListResponse, type LocksConfigureAutoLockBody, type LocksConfigureAutoLockOptions, type LocksConfigureAutoLockParameters, type LocksConfigureAutoLockRequest, type LocksConfigureAutoLockResponse, type LocksGetOptions, type LocksGetParameters, type LocksGetParams, type LocksGetRequest, type LocksGetResponse, type LocksListOptions, type LocksListParameters, type LocksListParams, type LocksListRequest, type LocksListResponse, type LocksLockDoorBody, type LocksLockDoorOptions, type LocksLockDoorParameters, type LocksLockDoorRequest, type LocksLockDoorResponse, type LocksSimulateKeypadCodeEntryBody, type LocksSimulateKeypadCodeEntryOptions, type LocksSimulateKeypadCodeEntryParameters, type LocksSimulateKeypadCodeEntryRequest, type LocksSimulateKeypadCodeEntryResponse, type LocksSimulateManualLockViaKeypadBody, type LocksSimulateManualLockViaKeypadOptions, type LocksSimulateManualLockViaKeypadParameters, type LocksSimulateManualLockViaKeypadRequest, type LocksSimulateManualLockViaKeypadResponse, type LocksUnlockDoorBody, type LocksUnlockDoorOptions, type LocksUnlockDoorParameters, type LocksUnlockDoorRequest, type LocksUnlockDoorResponse, type NoiseSensorsListOptions, type NoiseSensorsListParameters, type NoiseSensorsListParams, type NoiseSensorsListRequest, type NoiseSensorsListResponse, type NoiseSensorsNoiseThresholdsCreateBody, type NoiseSensorsNoiseThresholdsCreateOptions, type NoiseSensorsNoiseThresholdsCreateParameters, type NoiseSensorsNoiseThresholdsCreateRequest, type NoiseSensorsNoiseThresholdsCreateResponse, type NoiseSensorsNoiseThresholdsDeleteOptions, type NoiseSensorsNoiseThresholdsDeleteParameters, type NoiseSensorsNoiseThresholdsDeleteParams, type NoiseSensorsNoiseThresholdsDeleteRequest, type NoiseSensorsNoiseThresholdsDeleteResponse, type NoiseSensorsNoiseThresholdsGetOptions, type NoiseSensorsNoiseThresholdsGetParameters, type NoiseSensorsNoiseThresholdsGetParams, type NoiseSensorsNoiseThresholdsGetRequest, type NoiseSensorsNoiseThresholdsGetResponse, type NoiseSensorsNoiseThresholdsListOptions, type NoiseSensorsNoiseThresholdsListParameters, type NoiseSensorsNoiseThresholdsListParams, type NoiseSensorsNoiseThresholdsListRequest, type NoiseSensorsNoiseThresholdsListResponse, type NoiseSensorsNoiseThresholdsUpdateBody, type NoiseSensorsNoiseThresholdsUpdateOptions, type NoiseSensorsNoiseThresholdsUpdateParameters, type NoiseSensorsNoiseThresholdsUpdateRequest, type NoiseSensorsNoiseThresholdsUpdateResponse, type NoiseSensorsSimulateTriggerNoiseThresholdBody, type NoiseSensorsSimulateTriggerNoiseThresholdOptions, type NoiseSensorsSimulateTriggerNoiseThresholdParameters, type NoiseSensorsSimulateTriggerNoiseThresholdRequest, type NoiseSensorsSimulateTriggerNoiseThresholdResponse, type PhonesDeactivateOptions, type PhonesDeactivateParameters, type PhonesDeactivateParams, type PhonesDeactivateRequest, type PhonesDeactivateResponse, type PhonesGetOptions, type PhonesGetParameters, type PhonesGetParams, type PhonesGetRequest, type PhonesGetResponse, type PhonesListOptions, type PhonesListParameters, type PhonesListParams, type PhonesListRequest, type PhonesListResponse, type PhonesSimulateCreateSandboxPhoneBody, type PhonesSimulateCreateSandboxPhoneOptions, type PhonesSimulateCreateSandboxPhoneParameters, type PhonesSimulateCreateSandboxPhoneRequest, type PhonesSimulateCreateSandboxPhoneResponse, SeamActionAttemptError, SeamActionAttemptFailedError, SeamActionAttemptTimeoutError, type SeamConsoleV1GetResourceLocatorOptions, type SeamConsoleV1GetResourceLocatorParameters, type SeamConsoleV1GetResourceLocatorParams, type SeamConsoleV1GetResourceLocatorRequest, type SeamConsoleV1GetResourceLocatorResponse, type SeamConsoleV1TimelinesGetOptions, type SeamConsoleV1TimelinesGetParameters, type SeamConsoleV1TimelinesGetParams, type SeamConsoleV1TimelinesGetRequest, type SeamConsoleV1TimelinesGetResponse, type SeamCustomerV1AccessGrantsListOptions, type SeamCustomerV1AccessGrantsListParameters, type SeamCustomerV1AccessGrantsListParams, type SeamCustomerV1AccessGrantsListRequest, type SeamCustomerV1AccessGrantsListResponse, type SeamCustomerV1AccessGrantsUpdateBody, type SeamCustomerV1AccessGrantsUpdateOptions, type SeamCustomerV1AccessGrantsUpdateParameters, type SeamCustomerV1AccessGrantsUpdateRequest, type SeamCustomerV1AccessGrantsUpdateResponse, type SeamCustomerV1AccessMethodsEncodeBody, type SeamCustomerV1AccessMethodsEncodeOptions, type SeamCustomerV1AccessMethodsEncodeParameters, type SeamCustomerV1AccessMethodsEncodeRequest, type SeamCustomerV1AccessMethodsEncodeResponse, type SeamCustomerV1AutomationRunsListOptions, type SeamCustomerV1AutomationRunsListParameters, type SeamCustomerV1AutomationRunsListParams, type SeamCustomerV1AutomationRunsListRequest, type SeamCustomerV1AutomationRunsListResponse, type SeamCustomerV1AutomationsDeleteOptions, type SeamCustomerV1AutomationsDeleteParameters, type SeamCustomerV1AutomationsDeleteParams, type SeamCustomerV1AutomationsDeleteRequest, type SeamCustomerV1AutomationsDeleteResponse, type SeamCustomerV1AutomationsGetOptions, type SeamCustomerV1AutomationsGetParameters, type SeamCustomerV1AutomationsGetParams, type SeamCustomerV1AutomationsGetRequest, type SeamCustomerV1AutomationsGetResponse, type SeamCustomerV1AutomationsUpdateBody, type SeamCustomerV1AutomationsUpdateOptions, type SeamCustomerV1AutomationsUpdateParameters, type SeamCustomerV1AutomationsUpdateRequest, type SeamCustomerV1AutomationsUpdateResponse, type SeamCustomerV1ConnectorCustomersListOptions, type SeamCustomerV1ConnectorCustomersListParameters, type SeamCustomerV1ConnectorCustomersListParams, type SeamCustomerV1ConnectorCustomersListRequest, type SeamCustomerV1ConnectorCustomersListResponse, type SeamCustomerV1ConnectorsAuthorizeOptions, type SeamCustomerV1ConnectorsAuthorizeParameters, type SeamCustomerV1ConnectorsAuthorizeParams, type SeamCustomerV1ConnectorsAuthorizeRequest, type SeamCustomerV1ConnectorsAuthorizeResponse, type SeamCustomerV1ConnectorsConnectorTypesOptions, type SeamCustomerV1ConnectorsConnectorTypesParameters, type SeamCustomerV1ConnectorsConnectorTypesParams, type SeamCustomerV1ConnectorsConnectorTypesRequest, type SeamCustomerV1ConnectorsConnectorTypesResponse, type SeamCustomerV1ConnectorsCreateBody, type SeamCustomerV1ConnectorsCreateOptions, type SeamCustomerV1ConnectorsCreateParameters, type SeamCustomerV1ConnectorsCreateRequest, type SeamCustomerV1ConnectorsCreateResponse, type SeamCustomerV1ConnectorsDeleteBody, type SeamCustomerV1ConnectorsDeleteOptions, type SeamCustomerV1ConnectorsDeleteParameters, type SeamCustomerV1ConnectorsDeleteRequest, type SeamCustomerV1ConnectorsDeleteResponse, type SeamCustomerV1ConnectorsIcalValidateConfigBody, type SeamCustomerV1ConnectorsIcalValidateConfigOptions, type SeamCustomerV1ConnectorsIcalValidateConfigParameters, type SeamCustomerV1ConnectorsIcalValidateConfigRequest, type SeamCustomerV1ConnectorsIcalValidateConfigResponse, type SeamCustomerV1ConnectorsListOptions, type SeamCustomerV1ConnectorsListParameters, type SeamCustomerV1ConnectorsListParams, type SeamCustomerV1ConnectorsListRequest, type SeamCustomerV1ConnectorsListResponse, type SeamCustomerV1ConnectorsSyncBody, type SeamCustomerV1ConnectorsSyncOptions, type SeamCustomerV1ConnectorsSyncParameters, type SeamCustomerV1ConnectorsSyncRequest, type SeamCustomerV1ConnectorsSyncResponse, type SeamCustomerV1ConnectorsUpdateBody, type SeamCustomerV1ConnectorsUpdateOptions, type SeamCustomerV1ConnectorsUpdateParameters, type SeamCustomerV1ConnectorsUpdateRequest, type SeamCustomerV1ConnectorsUpdateResponse, type SeamCustomerV1CustomersAutomationsGetOptions, type SeamCustomerV1CustomersAutomationsGetParameters, type SeamCustomerV1CustomersAutomationsGetParams, type SeamCustomerV1CustomersAutomationsGetRequest, type SeamCustomerV1CustomersAutomationsGetResponse, type SeamCustomerV1CustomersAutomationsUpdateBody, type SeamCustomerV1CustomersAutomationsUpdateOptions, type SeamCustomerV1CustomersAutomationsUpdateParameters, type SeamCustomerV1CustomersAutomationsUpdateRequest, type SeamCustomerV1CustomersAutomationsUpdateResponse, type SeamCustomerV1CustomersListOptions, type SeamCustomerV1CustomersListParameters, type SeamCustomerV1CustomersListParams, type SeamCustomerV1CustomersListRequest, type SeamCustomerV1CustomersListResponse, type SeamCustomerV1CustomersMeOptions, type SeamCustomerV1CustomersMeParameters, type SeamCustomerV1CustomersMeParams, type SeamCustomerV1CustomersMeRequest, type SeamCustomerV1CustomersMeResponse, type SeamCustomerV1CustomersOpenPortalBody, type SeamCustomerV1CustomersOpenPortalOptions, type SeamCustomerV1CustomersOpenPortalParameters, type SeamCustomerV1CustomersOpenPortalRequest, type SeamCustomerV1CustomersOpenPortalResponse, type SeamCustomerV1EncodersListOptions, type SeamCustomerV1EncodersListParameters, type SeamCustomerV1EncodersListParams, type SeamCustomerV1EncodersListRequest, type SeamCustomerV1EncodersListResponse, type SeamCustomerV1EventsListOptions, type SeamCustomerV1EventsListParameters, type SeamCustomerV1EventsListParams, type SeamCustomerV1EventsListRequest, type SeamCustomerV1EventsListResponse, type SeamCustomerV1PortalsGetOptions, type SeamCustomerV1PortalsGetParameters, type SeamCustomerV1PortalsGetParams, type SeamCustomerV1PortalsGetRequest, type SeamCustomerV1PortalsGetResponse, type SeamCustomerV1PortalsUpdateBody, type SeamCustomerV1PortalsUpdateOptions, type SeamCustomerV1PortalsUpdateParameters, type SeamCustomerV1PortalsUpdateRequest, type SeamCustomerV1PortalsUpdateResponse, type SeamCustomerV1ReservationsGetOptions, type SeamCustomerV1ReservationsGetParameters, type SeamCustomerV1ReservationsGetParams, type SeamCustomerV1ReservationsGetRequest, type SeamCustomerV1ReservationsGetResponse, type SeamCustomerV1ReservationsListAccessGrantsOptions, type SeamCustomerV1ReservationsListAccessGrantsParameters, type SeamCustomerV1ReservationsListAccessGrantsParams, type SeamCustomerV1ReservationsListAccessGrantsRequest, type SeamCustomerV1ReservationsListAccessGrantsResponse, type SeamCustomerV1ReservationsListOptions, type SeamCustomerV1ReservationsListParameters, type SeamCustomerV1ReservationsListParams, type SeamCustomerV1ReservationsListRequest, type SeamCustomerV1ReservationsListResponse, type SeamCustomerV1SettingsGetOptions, type SeamCustomerV1SettingsGetParameters, type SeamCustomerV1SettingsGetParams, type SeamCustomerV1SettingsGetRequest, type SeamCustomerV1SettingsGetResponse, type SeamCustomerV1SettingsUpdateBody, type SeamCustomerV1SettingsUpdateOptions, type SeamCustomerV1SettingsUpdateParameters, type SeamCustomerV1SettingsUpdateRequest, type SeamCustomerV1SettingsUpdateResponse, type SeamCustomerV1SettingsVerticalResourceAliasesGetOptions, type SeamCustomerV1SettingsVerticalResourceAliasesGetParameters, type SeamCustomerV1SettingsVerticalResourceAliasesGetParams, type SeamCustomerV1SettingsVerticalResourceAliasesGetRequest, type SeamCustomerV1SettingsVerticalResourceAliasesGetResponse, type SeamCustomerV1SpacesCreateBody, type SeamCustomerV1SpacesCreateOptions, type SeamCustomerV1SpacesCreateParameters, type SeamCustomerV1SpacesCreateRequest, type SeamCustomerV1SpacesCreateResponse, type SeamCustomerV1SpacesListOptions, type SeamCustomerV1SpacesListParameters, type SeamCustomerV1SpacesListParams, type SeamCustomerV1SpacesListRequest, type SeamCustomerV1SpacesListReservationsOptions, type SeamCustomerV1SpacesListReservationsParameters, type SeamCustomerV1SpacesListReservationsParams, type SeamCustomerV1SpacesListReservationsRequest, type SeamCustomerV1SpacesListReservationsResponse, type SeamCustomerV1SpacesListResponse, type SeamCustomerV1SpacesPushCommonAreasBody, type SeamCustomerV1SpacesPushCommonAreasOptions, type SeamCustomerV1SpacesPushCommonAreasParameters, type SeamCustomerV1SpacesPushCommonAreasRequest, type SeamCustomerV1SpacesPushCommonAreasResponse, type SeamCustomerV1StaffMembersGetOptions, type SeamCustomerV1StaffMembersGetParameters, type SeamCustomerV1StaffMembersGetParams, type SeamCustomerV1StaffMembersGetRequest, type SeamCustomerV1StaffMembersGetResponse, type SeamCustomerV1StaffMembersListOptions, type SeamCustomerV1StaffMembersListParameters, type SeamCustomerV1StaffMembersListParams, type SeamCustomerV1StaffMembersListRequest, type SeamCustomerV1StaffMembersListResponse, SeamHttp, SeamHttpAccessCodes, SeamHttpAccessCodesSimulate, SeamHttpAccessCodesUnmanaged, SeamHttpAccessGrants, SeamHttpAccessGrantsUnmanaged, SeamHttpAccessMethods, SeamHttpAccessMethodsUnmanaged, SeamHttpAcs, SeamHttpAcsAccessGroups, SeamHttpAcsAccessGroupsUnmanaged, SeamHttpAcsCredentialPools, SeamHttpAcsCredentialProvisioningAutomations, SeamHttpAcsCredentials, SeamHttpAcsCredentialsUnmanaged, SeamHttpAcsEncoders, SeamHttpAcsEncodersSimulate, SeamHttpAcsEntrances, SeamHttpAcsSystems, SeamHttpAcsUsers, SeamHttpAcsUsersUnmanaged, SeamHttpActionAttempts, SeamHttpApiError, SeamHttpBridges, SeamHttpClientSessions, SeamHttpConnectWebviews, SeamHttpConnectedAccounts, SeamHttpConnectedAccountsSimulate, SeamHttpCustomers, SeamHttpCustomersReservations, SeamHttpDevices, SeamHttpDevicesSimulate, SeamHttpDevicesUnmanaged, type SeamHttpEndpointMutationPaths, type SeamHttpEndpointPaginatedQueryPaths, type SeamHttpEndpointQueryPaths, type SeamHttpEndpointWithoutWorkspaceMutationPaths, type SeamHttpEndpointWithoutWorkspaceQueryPaths, SeamHttpEndpoints, SeamHttpEndpointsWithoutWorkspace, SeamHttpEvents, type SeamHttpFromPublishableKeyOptions, SeamHttpInstantKeys, SeamHttpInvalidInputError, SeamHttpInvalidOptionsError, SeamHttpInvalidTokenError, SeamHttpLocks, SeamHttpLocksSimulate, SeamHttpMultiWorkspace, SeamHttpNoiseSensors, SeamHttpNoiseSensorsNoiseThresholds, SeamHttpNoiseSensorsSimulate, type SeamHttpOptions, type SeamHttpOptionsFromEnv, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, SeamHttpPhones, SeamHttpPhonesSimulate, SeamHttpRequest, type SeamHttpRequestOptions, SeamHttpSeamConsole, SeamHttpSeamConsoleV1, SeamHttpSeamConsoleV1Timelines, SeamHttpSeamCustomerV1, SeamHttpSeamCustomerV1AccessGrants, SeamHttpSeamCustomerV1AccessMethods, SeamHttpSeamCustomerV1AutomationRuns, SeamHttpSeamCustomerV1Automations, SeamHttpSeamCustomerV1ConnectorCustomers, SeamHttpSeamCustomerV1Connectors, SeamHttpSeamCustomerV1ConnectorsIcal, SeamHttpSeamCustomerV1Customers, SeamHttpSeamCustomerV1CustomersAutomations, SeamHttpSeamCustomerV1Encoders, SeamHttpSeamCustomerV1Events, SeamHttpSeamCustomerV1Portals, SeamHttpSeamCustomerV1Reservations, SeamHttpSeamCustomerV1Settings, SeamHttpSeamCustomerV1SettingsVerticalResourceAliases, SeamHttpSeamCustomerV1Spaces, SeamHttpSeamCustomerV1StaffMembers, SeamHttpSeamPartnerV1BuildingBlocks, SeamHttpSeamPartnerV1BuildingBlocksSpaces, SeamHttpSpaces, SeamHttpThermostats, SeamHttpThermostatsDailyPrograms, SeamHttpThermostatsSchedules, SeamHttpThermostatsSimulate, SeamHttpUnauthorizedError, SeamHttpUnstablePartner, SeamHttpUnstablePartnerBuildingBlocks, SeamHttpUserIdentities, SeamHttpUserIdentitiesEnrollmentAutomations, SeamHttpUserIdentitiesUnmanaged, SeamHttpWebhooks, SeamHttpWithoutWorkspace, SeamHttpWithoutWorkspaceInvalidOptionsError, type SeamHttpWithoutWorkspaceOptions, type SeamHttpWithoutWorkspaceOptionsFromEnv, type SeamHttpWithoutWorkspaceOptionsWithClient, type SeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken, type SeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken, SeamHttpWorkspaces, SeamHttpWorkspacesCustomizationProfiles, type SeamPageCursor, SeamPaginator, type SeamPartnerV1BuildingBlocksSpacesAutoMapOptions, type SeamPartnerV1BuildingBlocksSpacesAutoMapParameters, type SeamPartnerV1BuildingBlocksSpacesAutoMapParams, type SeamPartnerV1BuildingBlocksSpacesAutoMapRequest, type SeamPartnerV1BuildingBlocksSpacesAutoMapResponse, type SpacesAddAcsEntrancesBody, type SpacesAddAcsEntrancesOptions, type SpacesAddAcsEntrancesParameters, type SpacesAddAcsEntrancesRequest, type SpacesAddAcsEntrancesResponse, type SpacesAddConnectedAccountBody, type SpacesAddConnectedAccountOptions, type SpacesAddConnectedAccountParameters, type SpacesAddConnectedAccountRequest, type SpacesAddConnectedAccountResponse, type SpacesAddDevicesBody, type SpacesAddDevicesOptions, type SpacesAddDevicesParameters, type SpacesAddDevicesRequest, type SpacesAddDevicesResponse, type SpacesCreateBody, type SpacesCreateOptions, type SpacesCreateParameters, type SpacesCreateRequest, type SpacesCreateResponse, type SpacesDeleteOptions, type SpacesDeleteParameters, type SpacesDeleteParams, type SpacesDeleteRequest, type SpacesDeleteResponse, type SpacesGetOptions, type SpacesGetParameters, type SpacesGetParams, type SpacesGetRelatedOptions, type SpacesGetRelatedParameters, type SpacesGetRelatedParams, type SpacesGetRelatedRequest, type SpacesGetRelatedResponse, type SpacesGetRequest, type SpacesGetResponse, type SpacesListOptions, type SpacesListParameters, type SpacesListParams, type SpacesListRequest, type SpacesListResponse, type SpacesRemoveAcsEntrancesOptions, type SpacesRemoveAcsEntrancesParameters, type SpacesRemoveAcsEntrancesParams, type SpacesRemoveAcsEntrancesRequest, type SpacesRemoveAcsEntrancesResponse, type SpacesRemoveConnectedAccountOptions, type SpacesRemoveConnectedAccountParameters, type SpacesRemoveConnectedAccountParams, type SpacesRemoveConnectedAccountRequest, type SpacesRemoveConnectedAccountResponse, type SpacesRemoveDevicesOptions, type SpacesRemoveDevicesParameters, type SpacesRemoveDevicesParams, type SpacesRemoveDevicesRequest, type SpacesRemoveDevicesResponse, type SpacesUpdateBody, type SpacesUpdateOptions, type SpacesUpdateParameters, type SpacesUpdateRequest, type SpacesUpdateResponse, type ThermostatsActivateClimatePresetBody, type ThermostatsActivateClimatePresetOptions, type ThermostatsActivateClimatePresetParameters, type ThermostatsActivateClimatePresetRequest, type ThermostatsActivateClimatePresetResponse, type ThermostatsCoolBody, type ThermostatsCoolOptions, type ThermostatsCoolParameters, type ThermostatsCoolRequest, type ThermostatsCoolResponse, type ThermostatsCreateClimatePresetBody, type ThermostatsCreateClimatePresetOptions, type ThermostatsCreateClimatePresetParameters, type ThermostatsCreateClimatePresetRequest, type ThermostatsCreateClimatePresetResponse, type ThermostatsDailyProgramsCreateBody, type ThermostatsDailyProgramsCreateOptions, type ThermostatsDailyProgramsCreateParameters, type ThermostatsDailyProgramsCreateRequest, type ThermostatsDailyProgramsCreateResponse, type ThermostatsDailyProgramsDeleteOptions, type ThermostatsDailyProgramsDeleteParameters, type ThermostatsDailyProgramsDeleteParams, type ThermostatsDailyProgramsDeleteRequest, type ThermostatsDailyProgramsDeleteResponse, type ThermostatsDailyProgramsUpdateBody, type ThermostatsDailyProgramsUpdateOptions, type ThermostatsDailyProgramsUpdateParameters, type ThermostatsDailyProgramsUpdateRequest, type ThermostatsDailyProgramsUpdateResponse, type ThermostatsDeleteClimatePresetOptions, type ThermostatsDeleteClimatePresetParameters, type ThermostatsDeleteClimatePresetParams, type ThermostatsDeleteClimatePresetRequest, type ThermostatsDeleteClimatePresetResponse, type ThermostatsGetOptions, type ThermostatsGetParameters, type ThermostatsGetParams, type ThermostatsGetRequest, type ThermostatsGetResponse, type ThermostatsHeatBody, type ThermostatsHeatCoolBody, type ThermostatsHeatCoolOptions, type ThermostatsHeatCoolParameters, type ThermostatsHeatCoolRequest, type ThermostatsHeatCoolResponse, type ThermostatsHeatOptions, type ThermostatsHeatParameters, type ThermostatsHeatRequest, type ThermostatsHeatResponse, type ThermostatsListOptions, type ThermostatsListParameters, type ThermostatsListParams, type ThermostatsListRequest, type ThermostatsListResponse, type ThermostatsOffBody, type ThermostatsOffOptions, type ThermostatsOffParameters, type ThermostatsOffRequest, type ThermostatsOffResponse, type ThermostatsSchedulesCreateBody, type ThermostatsSchedulesCreateOptions, type ThermostatsSchedulesCreateParameters, type ThermostatsSchedulesCreateRequest, type ThermostatsSchedulesCreateResponse, type ThermostatsSchedulesDeleteOptions, type ThermostatsSchedulesDeleteParameters, type ThermostatsSchedulesDeleteParams, type ThermostatsSchedulesDeleteRequest, type ThermostatsSchedulesDeleteResponse, type ThermostatsSchedulesGetOptions, type ThermostatsSchedulesGetParameters, type ThermostatsSchedulesGetParams, type ThermostatsSchedulesGetRequest, type ThermostatsSchedulesGetResponse, type ThermostatsSchedulesListOptions, type ThermostatsSchedulesListParameters, type ThermostatsSchedulesListParams, type ThermostatsSchedulesListRequest, type ThermostatsSchedulesListResponse, type ThermostatsSchedulesUpdateBody, type ThermostatsSchedulesUpdateOptions, type ThermostatsSchedulesUpdateParameters, type ThermostatsSchedulesUpdateRequest, type ThermostatsSchedulesUpdateResponse, type ThermostatsSetFallbackClimatePresetBody, type ThermostatsSetFallbackClimatePresetOptions, type ThermostatsSetFallbackClimatePresetParameters, type ThermostatsSetFallbackClimatePresetRequest, type ThermostatsSetFallbackClimatePresetResponse, type ThermostatsSetFanModeBody, type ThermostatsSetFanModeOptions, type ThermostatsSetFanModeParameters, type ThermostatsSetFanModeRequest, type ThermostatsSetFanModeResponse, type ThermostatsSetHvacModeBody, type ThermostatsSetHvacModeOptions, type ThermostatsSetHvacModeParameters, type ThermostatsSetHvacModeRequest, type ThermostatsSetHvacModeResponse, type ThermostatsSetTemperatureThresholdBody, type ThermostatsSetTemperatureThresholdOptions, type ThermostatsSetTemperatureThresholdParameters, type ThermostatsSetTemperatureThresholdRequest, type ThermostatsSetTemperatureThresholdResponse, type ThermostatsSimulateHvacModeAdjustedBody, type ThermostatsSimulateHvacModeAdjustedOptions, type ThermostatsSimulateHvacModeAdjustedParameters, type ThermostatsSimulateHvacModeAdjustedRequest, type ThermostatsSimulateHvacModeAdjustedResponse, type ThermostatsSimulateTemperatureReachedBody, type ThermostatsSimulateTemperatureReachedOptions, type ThermostatsSimulateTemperatureReachedParameters, type ThermostatsSimulateTemperatureReachedRequest, type ThermostatsSimulateTemperatureReachedResponse, type ThermostatsUpdateClimatePresetBody, type ThermostatsUpdateClimatePresetOptions, type ThermostatsUpdateClimatePresetParameters, type ThermostatsUpdateClimatePresetRequest, type ThermostatsUpdateClimatePresetResponse, type ThermostatsUpdateWeeklyProgramBody, type ThermostatsUpdateWeeklyProgramOptions, type ThermostatsUpdateWeeklyProgramParameters, type ThermostatsUpdateWeeklyProgramRequest, type ThermostatsUpdateWeeklyProgramResponse, type UnstablePartnerBuildingBlocksConnectAccountsBody, type UnstablePartnerBuildingBlocksConnectAccountsOptions, type UnstablePartnerBuildingBlocksConnectAccountsParameters, type UnstablePartnerBuildingBlocksConnectAccountsRequest, type UnstablePartnerBuildingBlocksConnectAccountsResponse, type UnstablePartnerBuildingBlocksGenerateMagicLinkOptions, type UnstablePartnerBuildingBlocksGenerateMagicLinkParameters, type UnstablePartnerBuildingBlocksGenerateMagicLinkParams, type UnstablePartnerBuildingBlocksGenerateMagicLinkRequest, type UnstablePartnerBuildingBlocksGenerateMagicLinkResponse, type UnstablePartnerBuildingBlocksManageDevicesBody, type UnstablePartnerBuildingBlocksManageDevicesOptions, type UnstablePartnerBuildingBlocksManageDevicesParameters, type UnstablePartnerBuildingBlocksManageDevicesRequest, type UnstablePartnerBuildingBlocksManageDevicesResponse, type UnstablePartnerBuildingBlocksOrganizeSpacesBody, type UnstablePartnerBuildingBlocksOrganizeSpacesOptions, type UnstablePartnerBuildingBlocksOrganizeSpacesParameters, type UnstablePartnerBuildingBlocksOrganizeSpacesRequest, type UnstablePartnerBuildingBlocksOrganizeSpacesResponse, type UserIdentitiesAddAcsUserBody, type UserIdentitiesAddAcsUserOptions, type UserIdentitiesAddAcsUserParameters, type UserIdentitiesAddAcsUserRequest, type UserIdentitiesAddAcsUserResponse, type UserIdentitiesCreateBody, type UserIdentitiesCreateOptions, type UserIdentitiesCreateParameters, type UserIdentitiesCreateRequest, type UserIdentitiesCreateResponse, type UserIdentitiesDeleteOptions, type UserIdentitiesDeleteParameters, type UserIdentitiesDeleteParams, type UserIdentitiesDeleteRequest, type UserIdentitiesDeleteResponse, type UserIdentitiesEnrollmentAutomationsDeleteOptions, type UserIdentitiesEnrollmentAutomationsDeleteParameters, type UserIdentitiesEnrollmentAutomationsDeleteParams, type UserIdentitiesEnrollmentAutomationsDeleteRequest, type UserIdentitiesEnrollmentAutomationsDeleteResponse, type UserIdentitiesEnrollmentAutomationsGetOptions, type UserIdentitiesEnrollmentAutomationsGetParameters, type UserIdentitiesEnrollmentAutomationsGetParams, type UserIdentitiesEnrollmentAutomationsGetRequest, type UserIdentitiesEnrollmentAutomationsGetResponse, type UserIdentitiesEnrollmentAutomationsLaunchBody, type UserIdentitiesEnrollmentAutomationsLaunchOptions, type UserIdentitiesEnrollmentAutomationsLaunchParameters, type UserIdentitiesEnrollmentAutomationsLaunchRequest, type UserIdentitiesEnrollmentAutomationsLaunchResponse, type UserIdentitiesEnrollmentAutomationsListOptions, type UserIdentitiesEnrollmentAutomationsListParameters, type UserIdentitiesEnrollmentAutomationsListParams, type UserIdentitiesEnrollmentAutomationsListRequest, type UserIdentitiesEnrollmentAutomationsListResponse, type UserIdentitiesGenerateInstantKeyBody, type UserIdentitiesGenerateInstantKeyOptions, type UserIdentitiesGenerateInstantKeyParameters, type UserIdentitiesGenerateInstantKeyRequest, type UserIdentitiesGenerateInstantKeyResponse, type UserIdentitiesGetOptions, type UserIdentitiesGetParameters, type UserIdentitiesGetParams, type UserIdentitiesGetRequest, type UserIdentitiesGetResponse, type UserIdentitiesGrantAccessToDeviceBody, type UserIdentitiesGrantAccessToDeviceOptions, type UserIdentitiesGrantAccessToDeviceParameters, type UserIdentitiesGrantAccessToDeviceRequest, type UserIdentitiesGrantAccessToDeviceResponse, type UserIdentitiesListAccessibleDevicesOptions, type UserIdentitiesListAccessibleDevicesParameters, type UserIdentitiesListAccessibleDevicesParams, type UserIdentitiesListAccessibleDevicesRequest, type UserIdentitiesListAccessibleDevicesResponse, type UserIdentitiesListAccessibleEntrancesOptions, type UserIdentitiesListAccessibleEntrancesParameters, type UserIdentitiesListAccessibleEntrancesParams, type UserIdentitiesListAccessibleEntrancesRequest, type UserIdentitiesListAccessibleEntrancesResponse, type UserIdentitiesListAcsSystemsOptions, type UserIdentitiesListAcsSystemsParameters, type UserIdentitiesListAcsSystemsParams, type UserIdentitiesListAcsSystemsRequest, type UserIdentitiesListAcsSystemsResponse, type UserIdentitiesListAcsUsersOptions, type UserIdentitiesListAcsUsersParameters, type UserIdentitiesListAcsUsersParams, type UserIdentitiesListAcsUsersRequest, type UserIdentitiesListAcsUsersResponse, type UserIdentitiesListOptions, type UserIdentitiesListParameters, type UserIdentitiesListParams, type UserIdentitiesListRequest, type UserIdentitiesListResponse, type UserIdentitiesRemoveAcsUserOptions, type UserIdentitiesRemoveAcsUserParameters, type UserIdentitiesRemoveAcsUserParams, type UserIdentitiesRemoveAcsUserRequest, type UserIdentitiesRemoveAcsUserResponse, type UserIdentitiesRevokeAccessToDeviceOptions, type UserIdentitiesRevokeAccessToDeviceParameters, type UserIdentitiesRevokeAccessToDeviceParams, type UserIdentitiesRevokeAccessToDeviceRequest, type UserIdentitiesRevokeAccessToDeviceResponse, type UserIdentitiesUnmanagedGetOptions, type UserIdentitiesUnmanagedGetParameters, type UserIdentitiesUnmanagedGetParams, type UserIdentitiesUnmanagedGetRequest, type UserIdentitiesUnmanagedGetResponse, type UserIdentitiesUnmanagedListOptions, type UserIdentitiesUnmanagedListParameters, type UserIdentitiesUnmanagedListParams, type UserIdentitiesUnmanagedListRequest, type UserIdentitiesUnmanagedListResponse, type UserIdentitiesUnmanagedUpdateBody, type UserIdentitiesUnmanagedUpdateOptions, type UserIdentitiesUnmanagedUpdateParameters, type UserIdentitiesUnmanagedUpdateRequest, type UserIdentitiesUnmanagedUpdateResponse, type UserIdentitiesUpdateBody, type UserIdentitiesUpdateOptions, type UserIdentitiesUpdateParameters, type UserIdentitiesUpdateRequest, type UserIdentitiesUpdateResponse, type WebhooksCreateBody, type WebhooksCreateOptions, type WebhooksCreateParameters, type WebhooksCreateRequest, type WebhooksCreateResponse, type WebhooksDeleteOptions, type WebhooksDeleteParameters, type WebhooksDeleteParams, type WebhooksDeleteRequest, type WebhooksDeleteResponse, type WebhooksGetOptions, type WebhooksGetParameters, type WebhooksGetParams, type WebhooksGetRequest, type WebhooksGetResponse, type WebhooksListOptions, type WebhooksListParameters, type WebhooksListParams, type WebhooksListRequest, type WebhooksListResponse, type WebhooksUpdateBody, type WebhooksUpdateOptions, type WebhooksUpdateParameters, type WebhooksUpdateRequest, type WebhooksUpdateResponse, type WorkspacesCreateBody, type WorkspacesCreateOptions, type WorkspacesCreateParameters, type WorkspacesCreateRequest, type WorkspacesCreateResponse, type WorkspacesCustomizationProfilesCreateBody, type WorkspacesCustomizationProfilesCreateOptions, type WorkspacesCustomizationProfilesCreateParameters, type WorkspacesCustomizationProfilesCreateRequest, type WorkspacesCustomizationProfilesCreateResponse, type WorkspacesCustomizationProfilesGetOptions, type WorkspacesCustomizationProfilesGetParameters, type WorkspacesCustomizationProfilesGetParams, type WorkspacesCustomizationProfilesGetRequest, type WorkspacesCustomizationProfilesGetResponse, type WorkspacesCustomizationProfilesListOptions, type WorkspacesCustomizationProfilesListParameters, type WorkspacesCustomizationProfilesListParams, type WorkspacesCustomizationProfilesListRequest, type WorkspacesCustomizationProfilesListResponse, type WorkspacesCustomizationProfilesUpdateBody, type WorkspacesCustomizationProfilesUpdateOptions, type WorkspacesCustomizationProfilesUpdateParameters, type WorkspacesCustomizationProfilesUpdateRequest, type WorkspacesCustomizationProfilesUpdateResponse, type WorkspacesCustomizationProfilesUploadImagesBody, type WorkspacesCustomizationProfilesUploadImagesOptions, type WorkspacesCustomizationProfilesUploadImagesParameters, type WorkspacesCustomizationProfilesUploadImagesRequest, type WorkspacesCustomizationProfilesUploadImagesResponse, type WorkspacesFindAnythingOptions, type WorkspacesFindAnythingParameters, type WorkspacesFindAnythingParams, type WorkspacesFindAnythingRequest, type WorkspacesFindAnythingResponse, type WorkspacesGetOptions, type WorkspacesGetParameters, type WorkspacesGetParams, type WorkspacesGetRequest, type WorkspacesGetResponse, type WorkspacesListOptions, type WorkspacesListParameters, type WorkspacesListParams, type WorkspacesListRequest, type WorkspacesListResponse, type WorkspacesResetSandboxBody, type WorkspacesResetSandboxOptions, type WorkspacesResetSandboxParameters, type WorkspacesResetSandboxRequest, type WorkspacesResetSandboxResponse, type WorkspacesUpdateBody, type WorkspacesUpdateOptions, type WorkspacesUpdateParameters, type WorkspacesUpdateRequest, type WorkspacesUpdateResponse, errorInterceptor, getOpenapiSchema, isApiKey, isClientSessionToken, isConsoleSessionToken, isPersonalAccessToken, isPublishableKey, isSeamActionAttemptError, isSeamActionAttemptFailedError, isSeamActionAttemptTimeoutError, isSeamHttpApiError, isSeamHttpInvalidInputError, isSeamHttpOptionsWithApiKey, isSeamHttpOptionsWithClient, isSeamHttpOptionsWithClientSessionToken, isSeamHttpOptionsWithConsoleSessionToken, isSeamHttpOptionsWithPersonalAccessToken, isSeamHttpUnauthorizedError, isSeamHttpWithoutWorkspaceOptionsWithClient, isSeamHttpWithoutWorkspaceOptionsWithConsoleSessionToken, isSeamHttpWithoutWorkspaceOptionsWithPersonalAccessToken };