@seamapi/http 0.18.0 → 0.18.1

package/connect.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/seam/connect/index.js';
+export * from '@seamapi/url-search-params-serializer';

package/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/lib/seam/connect/action-attempt-types.d.ts

@@ -0,0 +1,17 @@
+export interface ActionAttempt {
+    action_attempt_id: string;
+    status: 'pending' | 'error' | 'success';
+}
+export type SuccessfulActionAttempt<T extends ActionAttempt> = T & {
+    status: 'success';
+};
+export type PendingActionAttempt<T extends ActionAttempt> = T & {
+    status: 'pending';
+};
+export type FailedActionAttempt<T extends ActionAttempt> = T & {
+    status: 'error';
+    error: {
+        type: string;
+        message: string;
+    };
+};

package/lib/seam/connect/api-error-types.d.ts

@@ -0,0 +1,8 @@
+export interface ApiErrorResponse {
+    error: ApiError;
+}
+export interface ApiError {
+    type: string;
+    message: string;
+    data?: unknown;
+}

package/lib/seam/connect/auth.d.ts

@@ -0,0 +1,10 @@
+import { type SeamHttpOptionsWithClientSessionToken } from './options.js';
+import type { Options } from './parse-options.js';
+type Headers = Record<string, string>;
+export declare const getAuthHeaders: (options: Options) => Headers;
+export declare const getAuthHeadersForClientSessionToken: ({ clientSessionToken, }: SeamHttpOptionsWithClientSessionToken) => Headers;
+export declare class SeamHttpInvalidTokenError extends Error {
+    constructor(message: string);
+}
+export declare const warnOnInsecureuserIdentifierKey: (userIdentifierKey: string) => void;
+export {};

package/lib/seam/connect/client.d.ts

@@ -0,0 +1,10 @@
+import { type AxiosInstance, type AxiosRequestConfig } from 'axios';
+import { type AxiosRetry } from 'axios-retry';
+export type Client = AxiosInstance;
+export interface ClientOptions {
+    axiosOptions?: AxiosRequestConfig;
+    axiosRetryOptions?: AxiosRetryConfig;
+}
+type AxiosRetryConfig = Parameters<AxiosRetry>[1];
+export declare const createClient: (options: ClientOptions) => AxiosInstance;
+export {};

package/lib/seam/connect/error-interceptor.d.ts

@@ -0,0 +1 @@
+export declare const errorInterceptor: (err: unknown) => Promise<void>;

package/lib/seam/connect/index.d.ts

@@ -0,0 +1,10 @@
+export { SeamHttpInvalidTokenError } from './auth.js';
+export * from './error-interceptor.js';
+export * from './openapi.js';
+export * from './options.js';
+export { isSeamActionAttemptError, isSeamActionAttemptFailedError, isSeamActionAttemptTimeoutError, SeamActionAttemptError, SeamActionAttemptFailedError, SeamActionAttemptTimeoutError, } from './resolve-action-attempt.js';
+export * from './routes/index.js';
+export * from './seam-http.js';
+export * from './seam-http-error.js';
+export * from './seam-http-multi-workspace.js';
+export { isApiKey, isClientSessionToken, isConsoleSessionToken, isPersonalAccessToken, isPublishableKey, } from './token.js';

package/lib/seam/connect/openapi.d.ts

@@ -0,0 +1,2 @@
+import type { openapi } from '@seamapi/types/connect';
+export declare const getOpenapiSchema: (endpoint?: string) => Promise<typeof openapi>;

package/lib/seam/connect/options.d.ts

@@ -0,0 +1,54 @@
+import type { Client, ClientOptions } from './client.js';
+import type { ResolveActionAttemptOptions } from './resolve-action-attempt.js';
+export type SeamHttpMultiWorkspaceOptions = SeamHttpMultiWorkspaceOptionsWithClient | SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken | SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken;
+export type SeamHttpOptions = SeamHttpOptionsFromEnv | SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken | SeamHttpOptionsWithConsoleSessionToken | SeamHttpOptionsWithPersonalAccessToken;
+interface SeamHttpCommonOptions extends ClientOptions, SeamHttpRequestOptions {
+    endpoint?: string;
+}
+export interface SeamHttpRequestOptions {
+    waitForActionAttempt?: boolean | ResolveActionAttemptOptions;
+}
+export interface SeamHttpFromPublishableKeyOptions extends SeamHttpCommonOptions {
+}
+export interface SeamHttpOptionsFromEnv extends SeamHttpCommonOptions {
+}
+export interface SeamHttpMultiWorkspaceOptionsWithClient extends SeamHttpRequestOptions {
+    client: Client;
+}
+export declare const isSeamHttpMultiWorkspaceOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpMultiWorkspaceOptionsWithClient;
+export interface SeamHttpOptionsWithClient extends SeamHttpRequestOptions {
+    client: Client;
+}
+export declare const isSeamHttpOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClient;
+export interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
+    apiKey: string;
+}
+export declare const isSeamHttpOptionsWithApiKey: (options: SeamHttpOptions) => options is SeamHttpOptionsWithApiKey;
+export interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOptions {
+    clientSessionToken: string;
+}
+export declare const isSeamHttpOptionsWithClientSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClientSessionToken;
+export interface SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
+    consoleSessionToken: string;
+}
+export declare const isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken: (options: SeamHttpOptions) => options is SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken;
+export interface SeamHttpOptionsWithConsoleSessionToken extends SeamHttpCommonOptions {
+    consoleSessionToken: string;
+    workspaceId: string;
+}
+export declare const isSeamHttpOptionsWithConsoleSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithConsoleSessionToken;
+export interface SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
+    personalAccessToken: string;
+}
+export declare const isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken: (options: SeamHttpOptions) => options is SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken;
+export interface SeamHttpOptionsWithPersonalAccessToken extends SeamHttpCommonOptions {
+    personalAccessToken: string;
+    workspaceId: string;
+}
+export declare const isSeamHttpOptionsWithPersonalAccessToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithPersonalAccessToken;
+export declare class SeamHttpInvalidOptionsError extends Error {
+    constructor(message: string);
+}
+export declare class SeamHttpMultiWorkspaceInvalidOptionsError extends SeamHttpInvalidOptionsError {
+}
+export {};

package/lib/seam/connect/parse-options.d.ts

@@ -0,0 +1,17 @@
+import type { Client, ClientOptions } from './client.js';
+import { type SeamHttpMultiWorkspaceOptions, type SeamHttpOptions, type SeamHttpRequestOptions } from './options.js';
+export declare const defaultEndpoint = "https://connect.getseam.com";
+export declare const sdkHeaders: {
+    'seam-sdk-name': string;
+    'seam-sdk-version': null;
+};
+export type Options = SeamHttpMultiWorkspaceOptions | (SeamHttpOptions & {
+    publishableKey?: string;
+});
+type ParsedOptions = Required<(ClientOptions | {
+    client: Client;
+}) & SeamHttpRequestOptions>;
+export declare const parseOptions: (apiKeyOrOptions: string | Options) => ParsedOptions;
+export declare const limitToSeamHttpRequestOptions: (options: Required<SeamHttpRequestOptions>) => Required<SeamHttpRequestOptions>;
+export declare const isSeamHttpRequestOption: (key: string) => key is "waitForActionAttempt";
+export {};

package/lib/seam/connect/resolve-action-attempt.d.ts

@@ -0,0 +1,21 @@
+import type { ActionAttempt, FailedActionAttempt, SuccessfulActionAttempt } from './action-attempt-types.js';
+import type { SeamHttpActionAttempts } from './routes/index.js';
+export interface ResolveActionAttemptOptions {
+    timeout?: number;
+    pollingInterval?: number;
+}
+export declare const resolveActionAttempt: <T extends ActionAttempt>(actionAttempt: T, actionAttempts: SeamHttpActionAttempts, { timeout, pollingInterval }: ResolveActionAttemptOptions) => Promise<SuccessfulActionAttempt<T>>;
+export declare const isSeamActionAttemptError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptError<T>;
+export declare class SeamActionAttemptError<T extends ActionAttempt> extends Error {
+    actionAttempt: T;
+    constructor(message: string, actionAttempt: T);
+}
+export declare const isSeamActionAttemptFailedError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptFailedError<T>;
+export declare class SeamActionAttemptFailedError<T extends ActionAttempt> extends SeamActionAttemptError<T> {
+    code: string;
+    constructor(actionAttempt: FailedActionAttempt<T>);
+}
+export declare const isSeamActionAttemptTimeoutError: <T extends ActionAttempt>(error: unknown) => error is SeamActionAttemptTimeoutError<T>;
+export declare class SeamActionAttemptTimeoutError<T extends ActionAttempt> extends SeamActionAttemptError<T> {
+    constructor(actionAttempt: T, timeout: number);
+}

package/lib/seam/connect/routes/access-codes-unmanaged.d.ts

@@ -0,0 +1,36 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAccessCodesUnmanaged {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    convertToManaged(body?: AccessCodesUnmanagedConvertToManagedBody): Promise<void>;
+    delete(body?: AccessCodesUnmanagedDeleteBody): Promise<void>;
+    get(body?: AccessCodesUnmanagedGetParams): Promise<AccessCodesUnmanagedGetResponse['access_code']>;
+    list(body?: AccessCodesUnmanagedListParams): Promise<AccessCodesUnmanagedListResponse['access_codes']>;
+    update(body?: AccessCodesUnmanagedUpdateBody): Promise<void>;
+}
+export type AccessCodesUnmanagedConvertToManagedBody = RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>;
+export type AccessCodesUnmanagedConvertToManagedResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/convert_to_managed'>>>;
+export type AccessCodesUnmanagedConvertToManagedOptions = never;
+export type AccessCodesUnmanagedDeleteBody = RouteRequestBody<'/access_codes/unmanaged/delete'>;
+export type AccessCodesUnmanagedDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/delete'>>>;
+export type AccessCodesUnmanagedDeleteOptions = never;
+export type AccessCodesUnmanagedGetParams = RouteRequestBody<'/access_codes/unmanaged/get'>;
+export type AccessCodesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/get'>>>;
+export type AccessCodesUnmanagedGetOptions = never;
+export type AccessCodesUnmanagedListParams = RouteRequestBody<'/access_codes/unmanaged/list'>;
+export type AccessCodesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/list'>>>;
+export type AccessCodesUnmanagedListOptions = never;
+export type AccessCodesUnmanagedUpdateBody = RouteRequestBody<'/access_codes/unmanaged/update'>;
+export type AccessCodesUnmanagedUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/update'>>>;
+export type AccessCodesUnmanagedUpdateOptions = never;

package/lib/seam/connect/routes/access-codes.d.ts

@@ -0,0 +1,50 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+import { SeamHttpAccessCodesUnmanaged } from './access-codes-unmanaged.js';
+export declare class SeamHttpAccessCodes {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    get unmanaged(): SeamHttpAccessCodesUnmanaged;
+    create(body?: AccessCodesCreateBody): Promise<AccessCodesCreateResponse['access_code']>;
+    createMultiple(body?: AccessCodesCreateMultipleBody): Promise<AccessCodesCreateMultipleResponse['access_codes']>;
+    delete(body?: AccessCodesDeleteBody): Promise<void>;
+    generateCode(body?: AccessCodesGenerateCodeBody): Promise<AccessCodesGenerateCodeResponse['generated_code']>;
+    get(body?: AccessCodesGetParams): Promise<AccessCodesGetResponse['access_code']>;
+    list(body?: AccessCodesListParams): Promise<AccessCodesListResponse['access_codes']>;
+    pullBackupAccessCode(body?: AccessCodesPullBackupAccessCodeBody): Promise<AccessCodesPullBackupAccessCodeResponse['backup_access_code']>;
+    update(body?: AccessCodesUpdateBody): Promise<void>;
+}
+export type AccessCodesCreateBody = RouteRequestBody<'/access_codes/create'>;
+export type AccessCodesCreateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create'>>>;
+export type AccessCodesCreateOptions = never;
+export type AccessCodesCreateMultipleBody = RouteRequestBody<'/access_codes/create_multiple'>;
+export type AccessCodesCreateMultipleResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create_multiple'>>>;
+export type AccessCodesCreateMultipleOptions = never;
+export type AccessCodesDeleteBody = RouteRequestBody<'/access_codes/delete'>;
+export type AccessCodesDeleteResponse = SetNonNullable<Required<RouteResponse<'/access_codes/delete'>>>;
+export type AccessCodesDeleteOptions = never;
+export type AccessCodesGenerateCodeBody = RouteRequestBody<'/access_codes/generate_code'>;
+export type AccessCodesGenerateCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/generate_code'>>>;
+export type AccessCodesGenerateCodeOptions = never;
+export type AccessCodesGetParams = RouteRequestBody<'/access_codes/get'>;
+export type AccessCodesGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get'>>>;
+export type AccessCodesGetOptions = never;
+export type AccessCodesListParams = RouteRequestBody<'/access_codes/list'>;
+export type AccessCodesListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/list'>>>;
+export type AccessCodesListOptions = never;
+export type AccessCodesPullBackupAccessCodeBody = RouteRequestBody<'/access_codes/pull_backup_access_code'>;
+export type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/pull_backup_access_code'>>>;
+export type AccessCodesPullBackupAccessCodeOptions = never;
+export type AccessCodesUpdateBody = RouteRequestBody<'/access_codes/update'>;
+export type AccessCodesUpdateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/update'>>>;
+export type AccessCodesUpdateOptions = never;

package/lib/seam/connect/routes/acs-access-groups.d.ts

@@ -0,0 +1,36 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsAccessGroups {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    addUser(body?: AcsAccessGroupsAddUserBody): Promise<void>;
+    get(body?: AcsAccessGroupsGetParams): Promise<AcsAccessGroupsGetResponse['acs_access_group']>;
+    list(body?: AcsAccessGroupsListParams): Promise<AcsAccessGroupsListResponse['acs_access_groups']>;
+    listUsers(body?: AcsAccessGroupsListUsersParams): Promise<AcsAccessGroupsListUsersResponse['acs_users']>;
+    removeUser(body?: AcsAccessGroupsRemoveUserBody): Promise<void>;
+}
+export type AcsAccessGroupsAddUserBody = RouteRequestBody<'/acs/access_groups/add_user'>;
+export type AcsAccessGroupsAddUserResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/add_user'>>>;
+export type AcsAccessGroupsAddUserOptions = never;
+export type AcsAccessGroupsGetParams = RouteRequestBody<'/acs/access_groups/get'>;
+export type AcsAccessGroupsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/get'>>>;
+export type AcsAccessGroupsGetOptions = never;
+export type AcsAccessGroupsListParams = RouteRequestBody<'/acs/access_groups/list'>;
+export type AcsAccessGroupsListResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list'>>>;
+export type AcsAccessGroupsListOptions = never;
+export type AcsAccessGroupsListUsersParams = RouteRequestBody<'/acs/access_groups/list_users'>;
+export type AcsAccessGroupsListUsersResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list_users'>>>;
+export type AcsAccessGroupsListUsersOptions = never;
+export type AcsAccessGroupsRemoveUserBody = RouteRequestBody<'/acs/access_groups/remove_user'>;
+export type AcsAccessGroupsRemoveUserResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/remove_user'>>>;
+export type AcsAccessGroupsRemoveUserOptions = never;

package/lib/seam/connect/routes/acs-credential-pools.d.ts

@@ -0,0 +1,20 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsCredentialPools {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    list(body?: AcsCredentialPoolsListParams): Promise<AcsCredentialPoolsListResponse['acs_credential_pools']>;
+}
+export type AcsCredentialPoolsListParams = RouteRequestBody<'/acs/credential_pools/list'>;
+export type AcsCredentialPoolsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credential_pools/list'>>>;
+export type AcsCredentialPoolsListOptions = never;

package/lib/seam/connect/routes/acs-credential-provisioning-automations.d.ts

@@ -0,0 +1,20 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsCredentialProvisioningAutomations {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    launch(body?: AcsCredentialProvisioningAutomationsLaunchBody): Promise<AcsCredentialProvisioningAutomationsLaunchResponse['acs_credential_provisioning_automation']>;
+}
+export type AcsCredentialProvisioningAutomationsLaunchBody = RouteRequestBody<'/acs/credential_provisioning_automations/launch'>;
+export type AcsCredentialProvisioningAutomationsLaunchResponse = SetNonNullable<Required<RouteResponse<'/acs/credential_provisioning_automations/launch'>>>;
+export type AcsCredentialProvisioningAutomationsLaunchOptions = never;

package/lib/seam/connect/routes/acs-credentials.d.ts

@@ -0,0 +1,44 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsCredentials {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    assign(body?: AcsCredentialsAssignBody): Promise<AcsCredentialsAssignResponse['acs_credential']>;
+    create(body?: AcsCredentialsCreateBody): Promise<AcsCredentialsCreateResponse['acs_credential']>;
+    delete(body?: AcsCredentialsDeleteBody): Promise<void>;
+    get(body?: AcsCredentialsGetParams): Promise<AcsCredentialsGetResponse['acs_credential']>;
+    list(body?: AcsCredentialsListParams): Promise<AcsCredentialsListResponse['acs_credentials']>;
+    unassign(body?: AcsCredentialsUnassignBody): Promise<AcsCredentialsUnassignResponse['acs_credential']>;
+    update(body?: AcsCredentialsUpdateBody): Promise<AcsCredentialsUpdateResponse['acs_credential']>;
+}
+export type AcsCredentialsAssignBody = RouteRequestBody<'/acs/credentials/assign'>;
+export type AcsCredentialsAssignResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/assign'>>>;
+export type AcsCredentialsAssignOptions = never;
+export type AcsCredentialsCreateBody = RouteRequestBody<'/acs/credentials/create'>;
+export type AcsCredentialsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/create'>>>;
+export type AcsCredentialsCreateOptions = never;
+export type AcsCredentialsDeleteBody = RouteRequestBody<'/acs/credentials/delete'>;
+export type AcsCredentialsDeleteResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/delete'>>>;
+export type AcsCredentialsDeleteOptions = never;
+export type AcsCredentialsGetParams = RouteRequestBody<'/acs/credentials/get'>;
+export type AcsCredentialsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/get'>>>;
+export type AcsCredentialsGetOptions = never;
+export type AcsCredentialsListParams = RouteRequestBody<'/acs/credentials/list'>;
+export type AcsCredentialsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list'>>>;
+export type AcsCredentialsListOptions = never;
+export type AcsCredentialsUnassignBody = RouteRequestBody<'/acs/credentials/unassign'>;
+export type AcsCredentialsUnassignResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/unassign'>>>;
+export type AcsCredentialsUnassignOptions = never;
+export type AcsCredentialsUpdateBody = RouteRequestBody<'/acs/credentials/update'>;
+export type AcsCredentialsUpdateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/update'>>>;
+export type AcsCredentialsUpdateOptions = never;

package/lib/seam/connect/routes/acs-entrances.d.ts

@@ -0,0 +1,32 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsEntrances {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    get(body?: AcsEntrancesGetParams): Promise<AcsEntrancesGetResponse['acs_entrance']>;
+    grantAccess(body?: AcsEntrancesGrantAccessBody): Promise<void>;
+    list(body?: AcsEntrancesListParams): Promise<AcsEntrancesListResponse['acs_entrances']>;
+    listCredentialsWithAccess(body?: AcsEntrancesListCredentialsWithAccessParams): Promise<AcsEntrancesListCredentialsWithAccessResponse['acs_credentials']>;
+}
+export type AcsEntrancesGetParams = RouteRequestBody<'/acs/entrances/get'>;
+export type AcsEntrancesGetResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/get'>>>;
+export type AcsEntrancesGetOptions = never;
+export type AcsEntrancesGrantAccessBody = RouteRequestBody<'/acs/entrances/grant_access'>;
+export type AcsEntrancesGrantAccessResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/grant_access'>>>;
+export type AcsEntrancesGrantAccessOptions = never;
+export type AcsEntrancesListParams = RouteRequestBody<'/acs/entrances/list'>;
+export type AcsEntrancesListResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/list'>>>;
+export type AcsEntrancesListOptions = never;
+export type AcsEntrancesListCredentialsWithAccessParams = RouteRequestBody<'/acs/entrances/list_credentials_with_access'>;
+export type AcsEntrancesListCredentialsWithAccessResponse = SetNonNullable<Required<RouteResponse<'/acs/entrances/list_credentials_with_access'>>>;
+export type AcsEntrancesListCredentialsWithAccessOptions = never;

package/lib/seam/connect/routes/acs-systems.d.ts

@@ -0,0 +1,24 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsSystems {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    get(body?: AcsSystemsGetParams): Promise<AcsSystemsGetResponse['acs_system']>;
+    list(body?: AcsSystemsListParams): Promise<AcsSystemsListResponse['acs_systems']>;
+}
+export type AcsSystemsGetParams = RouteRequestBody<'/acs/systems/get'>;
+export type AcsSystemsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/get'>>>;
+export type AcsSystemsGetOptions = never;
+export type AcsSystemsListParams = RouteRequestBody<'/acs/systems/list'>;
+export type AcsSystemsListResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list'>>>;
+export type AcsSystemsListOptions = never;

package/lib/seam/connect/routes/acs-users.d.ts

@@ -0,0 +1,60 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpAcsUsers {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    addToAccessGroup(body?: AcsUsersAddToAccessGroupBody): Promise<void>;
+    create(body?: AcsUsersCreateBody): Promise<AcsUsersCreateResponse['acs_user']>;
+    delete(body?: AcsUsersDeleteBody): Promise<void>;
+    get(body?: AcsUsersGetParams): Promise<AcsUsersGetResponse['acs_user']>;
+    list(body?: AcsUsersListParams): Promise<AcsUsersListResponse['acs_users']>;
+    listAccessibleEntrances(body?: AcsUsersListAccessibleEntrancesParams): Promise<AcsUsersListAccessibleEntrancesResponse['acs_entrances']>;
+    removeFromAccessGroup(body?: AcsUsersRemoveFromAccessGroupBody): Promise<void>;
+    revokeAccessToAllEntrances(body?: AcsUsersRevokeAccessToAllEntrancesBody): Promise<void>;
+    suspend(body?: AcsUsersSuspendBody): Promise<void>;
+    unsuspend(body?: AcsUsersUnsuspendBody): Promise<void>;
+    update(body?: AcsUsersUpdateBody): Promise<void>;
+}
+export type AcsUsersAddToAccessGroupBody = RouteRequestBody<'/acs/users/add_to_access_group'>;
+export type AcsUsersAddToAccessGroupResponse = SetNonNullable<Required<RouteResponse<'/acs/users/add_to_access_group'>>>;
+export type AcsUsersAddToAccessGroupOptions = never;
+export type AcsUsersCreateBody = RouteRequestBody<'/acs/users/create'>;
+export type AcsUsersCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/create'>>>;
+export type AcsUsersCreateOptions = never;
+export type AcsUsersDeleteBody = RouteRequestBody<'/acs/users/delete'>;
+export type AcsUsersDeleteResponse = SetNonNullable<Required<RouteResponse<'/acs/users/delete'>>>;
+export type AcsUsersDeleteOptions = never;
+export type AcsUsersGetParams = RouteRequestBody<'/acs/users/get'>;
+export type AcsUsersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/get'>>>;
+export type AcsUsersGetOptions = never;
+export type AcsUsersListParams = RouteRequestBody<'/acs/users/list'>;
+export type AcsUsersListResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list'>>>;
+export type AcsUsersListOptions = never;
+export type AcsUsersListAccessibleEntrancesParams = RouteRequestBody<'/acs/users/list_accessible_entrances'>;
+export type AcsUsersListAccessibleEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list_accessible_entrances'>>>;
+export type AcsUsersListAccessibleEntrancesOptions = never;
+export type AcsUsersRemoveFromAccessGroupBody = RouteRequestBody<'/acs/users/remove_from_access_group'>;
+export type AcsUsersRemoveFromAccessGroupResponse = SetNonNullable<Required<RouteResponse<'/acs/users/remove_from_access_group'>>>;
+export type AcsUsersRemoveFromAccessGroupOptions = never;
+export type AcsUsersRevokeAccessToAllEntrancesBody = RouteRequestBody<'/acs/users/revoke_access_to_all_entrances'>;
+export type AcsUsersRevokeAccessToAllEntrancesResponse = SetNonNullable<Required<RouteResponse<'/acs/users/revoke_access_to_all_entrances'>>>;
+export type AcsUsersRevokeAccessToAllEntrancesOptions = never;
+export type AcsUsersSuspendBody = RouteRequestBody<'/acs/users/suspend'>;
+export type AcsUsersSuspendResponse = SetNonNullable<Required<RouteResponse<'/acs/users/suspend'>>>;
+export type AcsUsersSuspendOptions = never;
+export type AcsUsersUnsuspendBody = RouteRequestBody<'/acs/users/unsuspend'>;
+export type AcsUsersUnsuspendResponse = SetNonNullable<Required<RouteResponse<'/acs/users/unsuspend'>>>;
+export type AcsUsersUnsuspendOptions = never;
+export type AcsUsersUpdateBody = RouteRequestBody<'/acs/users/update'>;
+export type AcsUsersUpdateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/update'>>>;
+export type AcsUsersUpdateOptions = never;

package/lib/seam/connect/routes/acs.d.ts

@@ -0,0 +1,28 @@
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+import { SeamHttpAcsAccessGroups } from './acs-access-groups.js';
+import { SeamHttpAcsCredentialPools } from './acs-credential-pools.js';
+import { SeamHttpAcsCredentialProvisioningAutomations } from './acs-credential-provisioning-automations.js';
+import { SeamHttpAcsCredentials } from './acs-credentials.js';
+import { SeamHttpAcsEntrances } from './acs-entrances.js';
+import { SeamHttpAcsSystems } from './acs-systems.js';
+import { SeamHttpAcsUsers } from './acs-users.js';
+export declare class SeamHttpAcs {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    get accessGroups(): SeamHttpAcsAccessGroups;
+    get credentialPools(): SeamHttpAcsCredentialPools;
+    get credentialProvisioningAutomations(): SeamHttpAcsCredentialProvisioningAutomations;
+    get credentials(): SeamHttpAcsCredentials;
+    get entrances(): SeamHttpAcsEntrances;
+    get systems(): SeamHttpAcsSystems;
+    get users(): SeamHttpAcsUsers;
+}

package/lib/seam/connect/routes/action-attempts.d.ts

@@ -0,0 +1,24 @@
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect';
+import type { SetNonNullable } from 'type-fest';
+import { type Client } from '../../../../lib/seam/connect/client.js';
+import { type SeamHttpFromPublishableKeyOptions, type SeamHttpOptions, type SeamHttpOptionsWithApiKey, type SeamHttpOptionsWithClient, type SeamHttpOptionsWithClientSessionToken, type SeamHttpOptionsWithConsoleSessionToken, type SeamHttpOptionsWithPersonalAccessToken, type SeamHttpRequestOptions } from '../../../../lib/seam/connect/options.js';
+export declare class SeamHttpActionAttempts {
+    client: Client;
+    readonly defaults: Required<SeamHttpRequestOptions>;
+    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;
+    updateClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken']): Promise<void>;
+    get(body?: ActionAttemptsGetParams, options?: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>): Promise<ActionAttemptsGetResponse['action_attempt']>;
+    list(body?: ActionAttemptsListParams): Promise<ActionAttemptsListResponse['action_attempts']>;
+}
+export type ActionAttemptsGetParams = RouteRequestBody<'/action_attempts/get'>;
+export type ActionAttemptsGetResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/get'>>>;
+export type ActionAttemptsGetOptions = Pick<SeamHttpRequestOptions, 'waitForActionAttempt'>;
+export type ActionAttemptsListParams = RouteRequestBody<'/action_attempts/list'>;
+export type ActionAttemptsListResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/list'>>>;
+export type ActionAttemptsListOptions = never;