@seamapi/http 1.37.0 → 1.38.0

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

@@ -175,193 +175,343 @@ export class SeamHttpAccessCodes {
   }
 
   create(
-    body?: AccessCodesCreateBody,
-  ): SeamHttpRequest<AccessCodesCreateResponse, 'access_code'> {
+    parameters?: AccessCodesCreateParameters,
+    options: AccessCodesCreateOptions = {},
+  ): AccessCodesCreateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/create',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'access_code',
+      options,
     })
   }
 
   createMultiple(
-    body?: AccessCodesCreateMultipleBody,
-  ): SeamHttpRequest<AccessCodesCreateMultipleResponse, 'access_codes'> {
+    parameters?: AccessCodesCreateMultipleParameters,
+    options: AccessCodesCreateMultipleOptions = {},
+  ): AccessCodesCreateMultipleRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/create_multiple',
       method: 'PUT',
-      body,
+      body: parameters,
       responseKey: 'access_codes',
+      options,
     })
   }
 
-  delete(params?: AccessCodesDeleteParams): SeamHttpRequest<void, undefined> {
+  delete(
+    parameters?: AccessCodesDeleteParameters,
+    options: AccessCodesDeleteOptions = {},
+  ): AccessCodesDeleteRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   generateCode(
-    params?: AccessCodesGenerateCodeParams,
-  ): SeamHttpRequest<AccessCodesGenerateCodeResponse, 'generated_code'> {
+    parameters?: AccessCodesGenerateCodeParameters,
+    options: AccessCodesGenerateCodeOptions = {},
+  ): AccessCodesGenerateCodeRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/generate_code',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'generated_code',
+      options,
     })
   }
 
   get(
-    params?: AccessCodesGetParams,
-  ): SeamHttpRequest<AccessCodesGetResponse, 'access_code'> {
+    parameters?: AccessCodesGetParameters,
+    options: AccessCodesGetOptions = {},
+  ): AccessCodesGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'access_code',
+      options,
     })
   }
 
   list(
-    params?: AccessCodesListParams,
-  ): SeamHttpRequest<AccessCodesListResponse, 'access_codes'> {
+    parameters?: AccessCodesListParameters,
+    options: AccessCodesListOptions = {},
+  ): AccessCodesListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'access_codes',
+      options,
     })
   }
 
   pullBackupAccessCode(
-    body?: AccessCodesPullBackupAccessCodeBody,
-  ): SeamHttpRequest<AccessCodesPullBackupAccessCodeResponse, 'access_code'> {
+    parameters?: AccessCodesPullBackupAccessCodeParameters,
+    options: AccessCodesPullBackupAccessCodeOptions = {},
+  ): AccessCodesPullBackupAccessCodeRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/pull_backup_access_code',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'access_code',
+      options,
     })
   }
 
   reportDeviceConstraints(
-    body?: AccessCodesReportDeviceConstraintsBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AccessCodesReportDeviceConstraintsParameters,
+    options: AccessCodesReportDeviceConstraintsOptions = {},
+  ): AccessCodesReportDeviceConstraintsRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/report_device_constraints',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
-  update(body?: AccessCodesUpdateBody): SeamHttpRequest<void, undefined> {
+  update(
+    parameters?: AccessCodesUpdateParameters,
+    options: AccessCodesUpdateOptions = {},
+  ): AccessCodesUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/update',
       method: 'PUT',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   updateMultiple(
-    body?: AccessCodesUpdateMultipleBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AccessCodesUpdateMultipleParameters,
+    options: AccessCodesUpdateMultipleOptions = {},
+  ): AccessCodesUpdateMultipleRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/update_multiple',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type AccessCodesCreateBody = RouteRequestBody<'/access_codes/create'>
+export type AccessCodesCreateParameters =
+  RouteRequestBody<'/access_codes/create'>
 
+/**
+ * @deprecated Use AccessCodesCreateParameters instead.
+ */
+export type AccessCodesCreateBody = AccessCodesCreateParameters
+
+/**
+ * @deprecated Use AccessCodesCreateRequest instead.
+ */
 export type AccessCodesCreateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/create'>>
 >
 
-export type AccessCodesCreateOptions = never
+export type AccessCodesCreateRequest = SeamHttpRequest<
+  AccessCodesCreateResponse,
+  'access_code'
+>
 
-export type AccessCodesCreateMultipleBody =
+export type AccessCodesCreateOptions = Record<string, never>
+
+export type AccessCodesCreateMultipleParameters =
   RouteRequestBody<'/access_codes/create_multiple'>
 
+/**
+ * @deprecated Use AccessCodesCreateMultipleParameters instead.
+ */
+export type AccessCodesCreateMultipleBody = AccessCodesCreateMultipleParameters
+
+/**
+ * @deprecated Use AccessCodesCreateMultipleRequest instead.
+ */
 export type AccessCodesCreateMultipleResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/create_multiple'>>
 >
 
-export type AccessCodesCreateMultipleOptions = never
+export type AccessCodesCreateMultipleRequest = SeamHttpRequest<
+  AccessCodesCreateMultipleResponse,
+  'access_codes'
+>
+
+export type AccessCodesCreateMultipleOptions = Record<string, never>
 
-export type AccessCodesDeleteParams = RouteRequestBody<'/access_codes/delete'>
+export type AccessCodesDeleteParameters =
+  RouteRequestBody<'/access_codes/delete'>
 
+/**
+ * @deprecated Use AccessCodesDeleteParameters instead.
+ */
+export type AccessCodesDeleteParams = AccessCodesDeleteParameters
+
+/**
+ * @deprecated Use AccessCodesDeleteRequest instead.
+ */
 export type AccessCodesDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/delete'>>
 >
 
-export type AccessCodesDeleteOptions = never
+export type AccessCodesDeleteRequest = SeamHttpRequest<void, undefined>
 
-export type AccessCodesGenerateCodeParams =
+export type AccessCodesDeleteOptions = Record<string, never>
+
+export type AccessCodesGenerateCodeParameters =
   RouteRequestBody<'/access_codes/generate_code'>
 
+/**
+ * @deprecated Use AccessCodesGenerateCodeParameters instead.
+ */
+export type AccessCodesGenerateCodeParams = AccessCodesGenerateCodeParameters
+
+/**
+ * @deprecated Use AccessCodesGenerateCodeRequest instead.
+ */
 export type AccessCodesGenerateCodeResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/generate_code'>>
 >
 
-export type AccessCodesGenerateCodeOptions = never
+export type AccessCodesGenerateCodeRequest = SeamHttpRequest<
+  AccessCodesGenerateCodeResponse,
+  'generated_code'
+>
+
+export type AccessCodesGenerateCodeOptions = Record<string, never>
 
-export type AccessCodesGetParams = RouteRequestBody<'/access_codes/get'>
+export type AccessCodesGetParameters = RouteRequestBody<'/access_codes/get'>
 
+/**
+ * @deprecated Use AccessCodesGetParameters instead.
+ */
+export type AccessCodesGetParams = AccessCodesGetParameters
+
+/**
+ * @deprecated Use AccessCodesGetRequest instead.
+ */
 export type AccessCodesGetResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/get'>>
 >
 
-export type AccessCodesGetOptions = never
+export type AccessCodesGetRequest = SeamHttpRequest<
+  AccessCodesGetResponse,
+  'access_code'
+>
+
+export type AccessCodesGetOptions = Record<string, never>
+
+export type AccessCodesListParameters = RouteRequestBody<'/access_codes/list'>
 
-export type AccessCodesListParams = RouteRequestBody<'/access_codes/list'>
+/**
+ * @deprecated Use AccessCodesListParameters instead.
+ */
+export type AccessCodesListParams = AccessCodesListParameters
 
+/**
+ * @deprecated Use AccessCodesListRequest instead.
+ */
 export type AccessCodesListResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/list'>>
 >
 
-export type AccessCodesListOptions = never
+export type AccessCodesListRequest = SeamHttpRequest<
+  AccessCodesListResponse,
+  'access_codes'
+>
+
+export type AccessCodesListOptions = Record<string, never>
 
-export type AccessCodesPullBackupAccessCodeBody =
+export type AccessCodesPullBackupAccessCodeParameters =
   RouteRequestBody<'/access_codes/pull_backup_access_code'>
 
+/**
+ * @deprecated Use AccessCodesPullBackupAccessCodeParameters instead.
+ */
+export type AccessCodesPullBackupAccessCodeBody =
+  AccessCodesPullBackupAccessCodeParameters
+
+/**
+ * @deprecated Use AccessCodesPullBackupAccessCodeRequest instead.
+ */
 export type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/pull_backup_access_code'>>
 >
 
-export type AccessCodesPullBackupAccessCodeOptions = never
+export type AccessCodesPullBackupAccessCodeRequest = SeamHttpRequest<
+  AccessCodesPullBackupAccessCodeResponse,
+  'access_code'
+>
 
-export type AccessCodesReportDeviceConstraintsBody =
+export type AccessCodesPullBackupAccessCodeOptions = Record<string, never>
+
+export type AccessCodesReportDeviceConstraintsParameters =
   RouteRequestBody<'/access_codes/report_device_constraints'>
 
+/**
+ * @deprecated Use AccessCodesReportDeviceConstraintsParameters instead.
+ */
+export type AccessCodesReportDeviceConstraintsBody =
+  AccessCodesReportDeviceConstraintsParameters
+
+/**
+ * @deprecated Use AccessCodesReportDeviceConstraintsRequest instead.
+ */
 export type AccessCodesReportDeviceConstraintsResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/report_device_constraints'>>
 >
 
-export type AccessCodesReportDeviceConstraintsOptions = never
+export type AccessCodesReportDeviceConstraintsRequest = SeamHttpRequest<
+  void,
+  undefined
+>
+
+export type AccessCodesReportDeviceConstraintsOptions = Record<string, never>
+
+export type AccessCodesUpdateParameters =
+  RouteRequestBody<'/access_codes/update'>
 
-export type AccessCodesUpdateBody = RouteRequestBody<'/access_codes/update'>
+/**
+ * @deprecated Use AccessCodesUpdateParameters instead.
+ */
+export type AccessCodesUpdateBody = AccessCodesUpdateParameters
 
+/**
+ * @deprecated Use AccessCodesUpdateRequest instead.
+ */
 export type AccessCodesUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/update'>>
 >
 
-export type AccessCodesUpdateOptions = never
+export type AccessCodesUpdateRequest = SeamHttpRequest<void, undefined>
+
+export type AccessCodesUpdateOptions = Record<string, never>
 
-export type AccessCodesUpdateMultipleBody =
+export type AccessCodesUpdateMultipleParameters =
   RouteRequestBody<'/access_codes/update_multiple'>
 
+/**
+ * @deprecated Use AccessCodesUpdateMultipleParameters instead.
+ */
+export type AccessCodesUpdateMultipleBody = AccessCodesUpdateMultipleParameters
+
+/**
+ * @deprecated Use AccessCodesUpdateMultipleRequest instead.
+ */
 export type AccessCodesUpdateMultipleResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/update_multiple'>>
 >
 
-export type AccessCodesUpdateMultipleOptions = never
+export type AccessCodesUpdateMultipleRequest = SeamHttpRequest<void, undefined>
+
+export type AccessCodesUpdateMultipleOptions = Record<string, never>

package/src/lib/seam/connect/routes/access-codes/simulate/simulate.ts

@@ -164,23 +164,31 @@ export class SeamHttpAccessCodesSimulate {
   }
 
   createUnmanagedAccessCode(
-    body?: AccessCodesSimulateCreateUnmanagedAccessCodeBody,
-  ): SeamHttpRequest<
-    AccessCodesSimulateCreateUnmanagedAccessCodeResponse,
-    'access_code'
-  > {
+    parameters?: AccessCodesSimulateCreateUnmanagedAccessCodeParameters,
+    options: AccessCodesSimulateCreateUnmanagedAccessCodeOptions = {},
+  ): AccessCodesSimulateCreateUnmanagedAccessCodeRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/simulate/create_unmanaged_access_code',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'access_code',
+      options,
     })
   }
 }
 
-export type AccessCodesSimulateCreateUnmanagedAccessCodeBody =
+export type AccessCodesSimulateCreateUnmanagedAccessCodeParameters =
   RouteRequestBody<'/access_codes/simulate/create_unmanaged_access_code'>
 
+/**
+ * @deprecated Use AccessCodesSimulateCreateUnmanagedAccessCodeParameters instead.
+ */
+export type AccessCodesSimulateCreateUnmanagedAccessCodeBody =
+  AccessCodesSimulateCreateUnmanagedAccessCodeParameters
+
+/**
+ * @deprecated Use AccessCodesSimulateCreateUnmanagedAccessCodeRequest instead.
+ */
 export type AccessCodesSimulateCreateUnmanagedAccessCodeResponse =
   SetNonNullable<
     Required<
@@ -188,4 +196,13 @@ export type AccessCodesSimulateCreateUnmanagedAccessCodeResponse =
     >
   >
 
-export type AccessCodesSimulateCreateUnmanagedAccessCodeOptions = never
+export type AccessCodesSimulateCreateUnmanagedAccessCodeRequest =
+  SeamHttpRequest<
+    AccessCodesSimulateCreateUnmanagedAccessCodeResponse,
+    'access_code'
+  >
+
+export type AccessCodesSimulateCreateUnmanagedAccessCodeOptions = Record<
+  string,
+  never
+>

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

@@ -164,102 +164,174 @@ export class SeamHttpAccessCodesUnmanaged {
   }
 
   convertToManaged(
-    body?: AccessCodesUnmanagedConvertToManagedBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AccessCodesUnmanagedConvertToManagedParameters,
+    options: AccessCodesUnmanagedConvertToManagedOptions = {},
+  ): AccessCodesUnmanagedConvertToManagedRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/unmanaged/convert_to_managed',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   delete(
-    params?: AccessCodesUnmanagedDeleteParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AccessCodesUnmanagedDeleteParameters,
+    options: AccessCodesUnmanagedDeleteOptions = {},
+  ): AccessCodesUnmanagedDeleteRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/unmanaged/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   get(
-    params?: AccessCodesUnmanagedGetParams,
-  ): SeamHttpRequest<AccessCodesUnmanagedGetResponse, 'access_code'> {
+    parameters?: AccessCodesUnmanagedGetParameters,
+    options: AccessCodesUnmanagedGetOptions = {},
+  ): AccessCodesUnmanagedGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/unmanaged/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'access_code',
+      options,
     })
   }
 
   list(
-    params?: AccessCodesUnmanagedListParams,
-  ): SeamHttpRequest<AccessCodesUnmanagedListResponse, 'access_codes'> {
+    parameters?: AccessCodesUnmanagedListParameters,
+    options: AccessCodesUnmanagedListOptions = {},
+  ): AccessCodesUnmanagedListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/unmanaged/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'access_codes',
+      options,
     })
   }
 
   update(
-    body?: AccessCodesUnmanagedUpdateBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AccessCodesUnmanagedUpdateParameters,
+    options: AccessCodesUnmanagedUpdateOptions = {},
+  ): AccessCodesUnmanagedUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/access_codes/unmanaged/update',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type AccessCodesUnmanagedConvertToManagedBody =
+export type AccessCodesUnmanagedConvertToManagedParameters =
   RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>
 
+/**
+ * @deprecated Use AccessCodesUnmanagedConvertToManagedParameters instead.
+ */
+export type AccessCodesUnmanagedConvertToManagedBody =
+  AccessCodesUnmanagedConvertToManagedParameters
+
+/**
+ * @deprecated Use AccessCodesUnmanagedConvertToManagedRequest instead.
+ */
 export type AccessCodesUnmanagedConvertToManagedResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/convert_to_managed'>>
 >
 
-export type AccessCodesUnmanagedConvertToManagedOptions = never
+export type AccessCodesUnmanagedConvertToManagedRequest = SeamHttpRequest<
+  void,
+  undefined
+>
+
+export type AccessCodesUnmanagedConvertToManagedOptions = Record<string, never>
 
-export type AccessCodesUnmanagedDeleteParams =
+export type AccessCodesUnmanagedDeleteParameters =
   RouteRequestBody<'/access_codes/unmanaged/delete'>
 
+/**
+ * @deprecated Use AccessCodesUnmanagedDeleteParameters instead.
+ */
+export type AccessCodesUnmanagedDeleteParams =
+  AccessCodesUnmanagedDeleteParameters
+
+/**
+ * @deprecated Use AccessCodesUnmanagedDeleteRequest instead.
+ */
 export type AccessCodesUnmanagedDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/delete'>>
 >
 
-export type AccessCodesUnmanagedDeleteOptions = never
+export type AccessCodesUnmanagedDeleteRequest = SeamHttpRequest<void, undefined>
 
-export type AccessCodesUnmanagedGetParams =
+export type AccessCodesUnmanagedDeleteOptions = Record<string, never>
+
+export type AccessCodesUnmanagedGetParameters =
   RouteRequestBody<'/access_codes/unmanaged/get'>
 
+/**
+ * @deprecated Use AccessCodesUnmanagedGetParameters instead.
+ */
+export type AccessCodesUnmanagedGetParams = AccessCodesUnmanagedGetParameters
+
+/**
+ * @deprecated Use AccessCodesUnmanagedGetRequest instead.
+ */
 export type AccessCodesUnmanagedGetResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/get'>>
 >
 
-export type AccessCodesUnmanagedGetOptions = never
+export type AccessCodesUnmanagedGetRequest = SeamHttpRequest<
+  AccessCodesUnmanagedGetResponse,
+  'access_code'
+>
+
+export type AccessCodesUnmanagedGetOptions = Record<string, never>
 
-export type AccessCodesUnmanagedListParams =
+export type AccessCodesUnmanagedListParameters =
   RouteRequestBody<'/access_codes/unmanaged/list'>
 
+/**
+ * @deprecated Use AccessCodesUnmanagedListParameters instead.
+ */
+export type AccessCodesUnmanagedListParams = AccessCodesUnmanagedListParameters
+
+/**
+ * @deprecated Use AccessCodesUnmanagedListRequest instead.
+ */
 export type AccessCodesUnmanagedListResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/list'>>
 >
 
-export type AccessCodesUnmanagedListOptions = never
+export type AccessCodesUnmanagedListRequest = SeamHttpRequest<
+  AccessCodesUnmanagedListResponse,
+  'access_codes'
+>
+
+export type AccessCodesUnmanagedListOptions = Record<string, never>
 
-export type AccessCodesUnmanagedUpdateBody =
+export type AccessCodesUnmanagedUpdateParameters =
   RouteRequestBody<'/access_codes/unmanaged/update'>
 
+/**
+ * @deprecated Use AccessCodesUnmanagedUpdateParameters instead.
+ */
+export type AccessCodesUnmanagedUpdateBody =
+  AccessCodesUnmanagedUpdateParameters
+
+/**
+ * @deprecated Use AccessCodesUnmanagedUpdateRequest instead.
+ */
 export type AccessCodesUnmanagedUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/access_codes/unmanaged/update'>>
 >
 
-export type AccessCodesUnmanagedUpdateOptions = never
+export type AccessCodesUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>
+
+export type AccessCodesUnmanagedUpdateOptions = Record<string, never>