@atproto/api 0.14.0-next.0 → 0.14.0-next.1

package/src/client/types/com/atproto/label/defs.ts

@@ -3,9 +3,15 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.label.defs'
 
 /** Metadata tag on an atproto resource (eg, repo or record). */
@@ -31,16 +37,18 @@ export interface Label {
   sig?: Uint8Array
 }
 
+const hashLabel = 'label'
+
 export function isLabel<V>(v: V) {
-  return is$typed(v, id, 'label')
+  return is$typed(v, id, hashLabel)
 }
 
-export function validateLabel(v: unknown) {
-  return lexicons.validate(`${id}#label`, v) as ValidationResult<Label>
+export function validateLabel<V>(v: V) {
+  return validate<Label & V>(v, id, hashLabel)
 }
 
-export function isValidLabel<V>(v: V): v is V & $Typed<Label> {
-  return isLabel(v) && validateLabel(v).success
+export function isValidLabel<V>(v: V) {
+  return isValid<Label>(v, id, hashLabel)
 }
 
 /** Metadata tags on an atproto record, published by the author within the record. */
@@ -49,19 +57,18 @@ export interface SelfLabels {
   values: SelfLabel[]
 }
 
+const hashSelfLabels = 'selfLabels'
+
 export function isSelfLabels<V>(v: V) {
-  return is$typed(v, id, 'selfLabels')
+  return is$typed(v, id, hashSelfLabels)
 }
 
-export function validateSelfLabels(v: unknown) {
-  return lexicons.validate(
-    `${id}#selfLabels`,
-    v,
-  ) as ValidationResult<SelfLabels>
+export function validateSelfLabels<V>(v: V) {
+  return validate<SelfLabels & V>(v, id, hashSelfLabels)
 }
 
-export function isValidSelfLabels<V>(v: V): v is V & $Typed<SelfLabels> {
-  return isSelfLabels(v) && validateSelfLabels(v).success
+export function isValidSelfLabels<V>(v: V) {
+  return isValid<SelfLabels>(v, id, hashSelfLabels)
 }
 
 /** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
@@ -71,16 +78,18 @@ export interface SelfLabel {
   val: string
 }
 
+const hashSelfLabel = 'selfLabel'
+
 export function isSelfLabel<V>(v: V) {
-  return is$typed(v, id, 'selfLabel')
+  return is$typed(v, id, hashSelfLabel)
 }
 
-export function validateSelfLabel(v: unknown) {
-  return lexicons.validate(`${id}#selfLabel`, v) as ValidationResult<SelfLabel>
+export function validateSelfLabel<V>(v: V) {
+  return validate<SelfLabel & V>(v, id, hashSelfLabel)
 }
 
-export function isValidSelfLabel<V>(v: V): v is V & $Typed<SelfLabel> {
-  return isSelfLabel(v) && validateSelfLabel(v).success
+export function isValidSelfLabel<V>(v: V) {
+  return isValid<SelfLabel>(v, id, hashSelfLabel)
 }
 
 /** Declares a label value and its expected interpretations and behaviors. */
@@ -99,21 +108,18 @@ export interface LabelValueDefinition {
   locales: LabelValueDefinitionStrings[]
 }
 
+const hashLabelValueDefinition = 'labelValueDefinition'
+
 export function isLabelValueDefinition<V>(v: V) {
-  return is$typed(v, id, 'labelValueDefinition')
+  return is$typed(v, id, hashLabelValueDefinition)
 }
 
-export function validateLabelValueDefinition(v: unknown) {
-  return lexicons.validate(
-    `${id}#labelValueDefinition`,
-    v,
-  ) as ValidationResult<LabelValueDefinition>
+export function validateLabelValueDefinition<V>(v: V) {
+  return validate<LabelValueDefinition & V>(v, id, hashLabelValueDefinition)
 }
 
-export function isValidLabelValueDefinition<V>(
-  v: V,
-): v is V & $Typed<LabelValueDefinition> {
-  return isLabelValueDefinition(v) && validateLabelValueDefinition(v).success
+export function isValidLabelValueDefinition<V>(v: V) {
+  return isValid<LabelValueDefinition>(v, id, hashLabelValueDefinition)
 }
 
 /** Strings which describe the label in the UI, localized into a specific language. */
@@ -127,23 +133,25 @@ export interface LabelValueDefinitionStrings {
   description: string
 }
 
+const hashLabelValueDefinitionStrings = 'labelValueDefinitionStrings'
+
 export function isLabelValueDefinitionStrings<V>(v: V) {
-  return is$typed(v, id, 'labelValueDefinitionStrings')
+  return is$typed(v, id, hashLabelValueDefinitionStrings)
 }
 
-export function validateLabelValueDefinitionStrings(v: unknown) {
-  return lexicons.validate(
-    `${id}#labelValueDefinitionStrings`,
+export function validateLabelValueDefinitionStrings<V>(v: V) {
+  return validate<LabelValueDefinitionStrings & V>(
     v,
-  ) as ValidationResult<LabelValueDefinitionStrings>
+    id,
+    hashLabelValueDefinitionStrings,
+  )
 }
 
-export function isValidLabelValueDefinitionStrings<V>(
-  v: V,
-): v is V & $Typed<LabelValueDefinitionStrings> {
-  return (
-    isLabelValueDefinitionStrings(v) &&
-    validateLabelValueDefinitionStrings(v).success
+export function isValidLabelValueDefinitionStrings<V>(v: V) {
+  return isValid<LabelValueDefinitionStrings>(
+    v,
+    id,
+    hashLabelValueDefinitionStrings,
   )
 }
 

package/src/client/types/com/atproto/label/queryLabels.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoLabelDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.label.queryLabels'
 
 export interface QueryParams {

package/src/client/types/com/atproto/label/subscribeLabels.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoLabelDefs from './defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.label.subscribeLabels'
 
 export interface Labels {
@@ -16,16 +22,18 @@ export interface Labels {
   labels: ComAtprotoLabelDefs.Label[]
 }
 
+const hashLabels = 'labels'
+
 export function isLabels<V>(v: V) {
-  return is$typed(v, id, 'labels')
+  return is$typed(v, id, hashLabels)
 }
 
-export function validateLabels(v: unknown) {
-  return lexicons.validate(`${id}#labels`, v) as ValidationResult<Labels>
+export function validateLabels<V>(v: V) {
+  return validate<Labels & V>(v, id, hashLabels)
 }
 
-export function isValidLabels<V>(v: V): v is V & $Typed<Labels> {
-  return isLabels(v) && validateLabels(v).success
+export function isValidLabels<V>(v: V) {
+  return isValid<Labels>(v, id, hashLabels)
 }
 
 export interface Info {
@@ -34,14 +42,16 @@ export interface Info {
   message?: string
 }
 
+const hashInfo = 'info'
+
 export function isInfo<V>(v: V) {
-  return is$typed(v, id, 'info')
+  return is$typed(v, id, hashInfo)
 }
 
-export function validateInfo(v: unknown) {
-  return lexicons.validate(`${id}#info`, v) as ValidationResult<Info>
+export function validateInfo<V>(v: V) {
+  return validate<Info & V>(v, id, hashInfo)
 }
 
-export function isValidInfo<V>(v: V): v is V & $Typed<Info> {
-  return isInfo(v) && validateInfo(v).success
+export function isValidInfo<V>(v: V) {
+  return isValid<Info>(v, id, hashInfo)
 }

package/src/client/types/com/atproto/moderation/createReport.ts

@@ -4,12 +4,18 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoModerationDefs from './defs'
-import * as ComAtprotoAdminDefs from '../admin/defs'
-import * as ComAtprotoRepoStrongRef from '../repo/strongRef'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoModerationDefs from './defs'
+import type * as ComAtprotoAdminDefs from '../admin/defs'
+import type * as ComAtprotoRepoStrongRef from '../repo/strongRef'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.moderation.createReport'
 
 export interface QueryParams {}

package/src/client/types/com/atproto/moderation/defs.ts

@@ -3,9 +3,15 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.moderation.defs'
 
 export type ReasonType =

package/src/client/types/com/atproto/repo/applyWrites.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoRepoDefs from './defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.applyWrites'
 
 export interface QueryParams {}
@@ -66,16 +72,18 @@ export interface Create {
   value: { [_ in string]: unknown }
 }
 
+const hashCreate = 'create'
+
 export function isCreate<V>(v: V) {
-  return is$typed(v, id, 'create')
+  return is$typed(v, id, hashCreate)
 }
 
-export function validateCreate(v: unknown) {
-  return lexicons.validate(`${id}#create`, v) as ValidationResult<Create>
+export function validateCreate<V>(v: V) {
+  return validate<Create & V>(v, id, hashCreate)
 }
 
-export function isValidCreate<V>(v: V): v is V & $Typed<Create> {
-  return isCreate(v) && validateCreate(v).success
+export function isValidCreate<V>(v: V) {
+  return isValid<Create>(v, id, hashCreate)
 }
 
 /** Operation which updates an existing record. */
@@ -86,16 +94,18 @@ export interface Update {
   value: { [_ in string]: unknown }
 }
 
+const hashUpdate = 'update'
+
 export function isUpdate<V>(v: V) {
-  return is$typed(v, id, 'update')
+  return is$typed(v, id, hashUpdate)
 }
 
-export function validateUpdate(v: unknown) {
-  return lexicons.validate(`${id}#update`, v) as ValidationResult<Update>
+export function validateUpdate<V>(v: V) {
+  return validate<Update & V>(v, id, hashUpdate)
 }
 
-export function isValidUpdate<V>(v: V): v is V & $Typed<Update> {
-  return isUpdate(v) && validateUpdate(v).success
+export function isValidUpdate<V>(v: V) {
+  return isValid<Update>(v, id, hashUpdate)
 }
 
 /** Operation which deletes an existing record. */
@@ -105,16 +115,18 @@ export interface Delete {
   rkey: string
 }
 
+const hashDelete = 'delete'
+
 export function isDelete<V>(v: V) {
-  return is$typed(v, id, 'delete')
+  return is$typed(v, id, hashDelete)
 }
 
-export function validateDelete(v: unknown) {
-  return lexicons.validate(`${id}#delete`, v) as ValidationResult<Delete>
+export function validateDelete<V>(v: V) {
+  return validate<Delete & V>(v, id, hashDelete)
 }
 
-export function isValidDelete<V>(v: V): v is V & $Typed<Delete> {
-  return isDelete(v) && validateDelete(v).success
+export function isValidDelete<V>(v: V) {
+  return isValid<Delete>(v, id, hashDelete)
 }
 
 export interface CreateResult {
@@ -124,19 +136,18 @@ export interface CreateResult {
   validationStatus?: 'valid' | 'unknown' | (string & {})
 }
 
+const hashCreateResult = 'createResult'
+
 export function isCreateResult<V>(v: V) {
-  return is$typed(v, id, 'createResult')
+  return is$typed(v, id, hashCreateResult)
 }
 
-export function validateCreateResult(v: unknown) {
-  return lexicons.validate(
-    `${id}#createResult`,
-    v,
-  ) as ValidationResult<CreateResult>
+export function validateCreateResult<V>(v: V) {
+  return validate<CreateResult & V>(v, id, hashCreateResult)
 }
 
-export function isValidCreateResult<V>(v: V): v is V & $Typed<CreateResult> {
-  return isCreateResult(v) && validateCreateResult(v).success
+export function isValidCreateResult<V>(v: V) {
+  return isValid<CreateResult>(v, id, hashCreateResult)
 }
 
 export interface UpdateResult {
@@ -146,36 +157,34 @@ export interface UpdateResult {
   validationStatus?: 'valid' | 'unknown' | (string & {})
 }
 
+const hashUpdateResult = 'updateResult'
+
 export function isUpdateResult<V>(v: V) {
-  return is$typed(v, id, 'updateResult')
+  return is$typed(v, id, hashUpdateResult)
 }
 
-export function validateUpdateResult(v: unknown) {
-  return lexicons.validate(
-    `${id}#updateResult`,
-    v,
-  ) as ValidationResult<UpdateResult>
+export function validateUpdateResult<V>(v: V) {
+  return validate<UpdateResult & V>(v, id, hashUpdateResult)
 }
 
-export function isValidUpdateResult<V>(v: V): v is V & $Typed<UpdateResult> {
-  return isUpdateResult(v) && validateUpdateResult(v).success
+export function isValidUpdateResult<V>(v: V) {
+  return isValid<UpdateResult>(v, id, hashUpdateResult)
 }
 
 export interface DeleteResult {
   $type?: $Type<'com.atproto.repo.applyWrites', 'deleteResult'>
 }
 
+const hashDeleteResult = 'deleteResult'
+
 export function isDeleteResult<V>(v: V) {
-  return is$typed(v, id, 'deleteResult')
+  return is$typed(v, id, hashDeleteResult)
 }
 
-export function validateDeleteResult(v: unknown) {
-  return lexicons.validate(
-    `${id}#deleteResult`,
-    v,
-  ) as ValidationResult<DeleteResult>
+export function validateDeleteResult<V>(v: V) {
+  return validate<DeleteResult & V>(v, id, hashDeleteResult)
 }
 
-export function isValidDeleteResult<V>(v: V): v is V & $Typed<DeleteResult> {
-  return isDeleteResult(v) && validateDeleteResult(v).success
+export function isValidDeleteResult<V>(v: V) {
+  return isValid<DeleteResult>(v, id, hashDeleteResult)
 }

package/src/client/types/com/atproto/repo/createRecord.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoRepoDefs from './defs'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.createRecord'
 
 export interface QueryParams {}

package/src/client/types/com/atproto/repo/defs.ts

@@ -3,9 +3,15 @@
  */
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.defs'
 
 export interface CommitMeta {
@@ -14,17 +20,16 @@ export interface CommitMeta {
   rev: string
 }
 
+const hashCommitMeta = 'commitMeta'
+
 export function isCommitMeta<V>(v: V) {
-  return is$typed(v, id, 'commitMeta')
+  return is$typed(v, id, hashCommitMeta)
 }
 
-export function validateCommitMeta(v: unknown) {
-  return lexicons.validate(
-    `${id}#commitMeta`,
-    v,
-  ) as ValidationResult<CommitMeta>
+export function validateCommitMeta<V>(v: V) {
+  return validate<CommitMeta & V>(v, id, hashCommitMeta)
 }
 
-export function isValidCommitMeta<V>(v: V): v is V & $Typed<CommitMeta> {
-  return isCommitMeta(v) && validateCommitMeta(v).success
+export function isValidCommitMeta<V>(v: V) {
+  return isValid<CommitMeta>(v, id, hashCommitMeta)
 }

package/src/client/types/com/atproto/repo/deleteRecord.ts

@@ -4,10 +4,16 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-import * as ComAtprotoRepoDefs from './defs'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.deleteRecord'
 
 export interface QueryParams {}

package/src/client/types/com/atproto/repo/describeRepo.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.describeRepo'
 
 export interface QueryParams {

package/src/client/types/com/atproto/repo/getRecord.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.getRecord'
 
 export interface QueryParams {

package/src/client/types/com/atproto/repo/importRepo.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
 
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.importRepo'
 
 export interface QueryParams {}

package/src/client/types/com/atproto/repo/listMissingBlobs.ts

@@ -4,9 +4,15 @@
 import { HeadersMap, XRPCError } from '@atproto/xrpc'
 import { ValidationResult, BlobRef } from '@atproto/lexicon'
 import { CID } from 'multiformats/cid'
-import { $Type, $Typed, is$typed, OmitKey } from '../../../../util'
-import { lexicons } from '../../../../lexicons'
-
+import {
+  isValid as _isValid,
+  validate as _validate,
+} from '../../../../lexicons'
+import { $Type, $Typed, is$typed as _is$typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  isValid = _isValid,
+  validate = _validate
 const id = 'com.atproto.repo.listMissingBlobs'
 
 export interface QueryParams {
@@ -42,17 +48,16 @@ export interface RecordBlob {
   recordUri: string
 }
 
+const hashRecordBlob = 'recordBlob'
+
 export function isRecordBlob<V>(v: V) {
-  return is$typed(v, id, 'recordBlob')
+  return is$typed(v, id, hashRecordBlob)
 }
 
-export function validateRecordBlob(v: unknown) {
-  return lexicons.validate(
-    `${id}#recordBlob`,
-    v,
-  ) as ValidationResult<RecordBlob>
+export function validateRecordBlob<V>(v: V) {
+  return validate<RecordBlob & V>(v, id, hashRecordBlob)
 }
 
-export function isValidRecordBlob<V>(v: V): v is V & $Typed<RecordBlob> {
-  return isRecordBlob(v) && validateRecordBlob(v).success
+export function isValidRecordBlob<V>(v: V) {
+  return isValid<RecordBlob>(v, id, hashRecordBlob)
 }