here are the relevant database types:
```typescript
import { Type } from 'class-transformer';
import {
 IsString,
 IsNotEmpty,
 IsNumber,
 IsPositive,
 IsEnum,
 IsArray,
 ValidateNested,
} from 'class-validator';
import { EntityStatus } from '../enums/EntityStatus';
import { PassOfferingInterval } from '../enums/PassOfferingInterval';
import { staticImplements, StaticModelable, Model } from '../Model';
import { RecurrenceRule } from '../types/RecurrenceRule';
import { VendDocumentReference } from '../types/VendDocumentReference';
import { IsNullable } from '../validators/IsNullable';

@staticImplements()
export class PassOffering extends Model {
 static collectionPath = 'passOfferings';

 /\*\* The human-readable name of the pass, eg. "Monthly Parking" \*/
 @IsString()
 @IsNotEmpty()
 name: string;

 @IsNullable()
 @ValidateNested()
 @Type(() => VendDocumentReference)
 businessRef: VendDocumentReference | null;

 /\*\* eg. the "1" in "1 month" \*/
 @IsNumber({ maxDecimalPlaces: 0 })
 @IsPositive()
 intervalValue: number;

 /\*\* eg. the "month" in "1 month" \*/
 @IsEnum(PassOfferingInterval)
 intervalPeriod: PassOfferingInterval;

 /\*\*
 \* Number of times a pass can be used within the interval
 \*
 \* `null` => unlimited uses
 \*/
 @IsNullable()
 @IsNumber({ maxDecimalPlaces: 0 })
 @IsPositive()
 parkLimit: number | null;

 /\*\*
 \* Max number of simultaneous active sessions the pass can have. Used for flex pass
 \* where a business may have 100 allowed passes distributed to 500 employees
 \* on a first-come-first-serve basis
 \*
 \* `null` => unlimited uses
 \*/
 @IsNullable()
 @IsNumber({ maxDecimalPlaces: 0 })
 @IsPositive()
 maxSimultaneousSessions: number | null;

 @Type(() => RecurrenceRule)
 @IsArray()
 @ValidateNested({ each: true })
 rules: RecurrenceRule[];

 @IsEnum(EntityStatus)
 status: EntityStatus;
}
import { Type } from 'class-transformer';
import {
 IsDate,
 IsNotEmpty,
 IsNumber,
 IsPositive,
 IsString,
 ValidateNested,
} from 'class-validator';
import { IsNullable } from '../validators/IsNullable';
import { EnterExitRule } from './EnterExitRule';

export class RecurrenceRule {
 /\*\* Rules for the users entry \*/
 @IsNullable()
 @Type(() => EnterExitRule)
 @ValidateNested()
 enter: EnterExitRule | null;

 /\*\* Rules for the users exit \*/
 @IsNullable()
 @Type(() => EnterExitRule)
 @ValidateNested()
 exit: EnterExitRule | null;

 /\*\* milliseconds \*/
 @IsNullable()
 @IsNumber({ maxDecimalPlaces: 0 })
 @IsPositive()
 minDuration: number | null;

 /\*\* milliseconds \*/
 @IsNullable()
 @IsNumber({ maxDecimalPlaces: 0 })
 @IsPositive()
 maxDuration: number | null;

 // TODO: RRule validation
 // @IsRRuleSet({ message: 'Not a valid RRuleSet' })
 @IsString()
 @IsNotEmpty()
 recurrence: string;
}
import { Type } from 'class-transformer';
import { ValidateNested, IsBoolean } from 'class-validator';
import { IsNullable } from '../validators/IsNullable';
import { RuleTimeBoundary } from './RuleTimeBoundary';

export class EnterExitRule {
 /\*\* Timing which user must perform action \_before\_ in order for rule to apply \*/
 @IsNullable()
 @ValidateNested()
 @Type(() => RuleTimeBoundary)
 before: RuleTimeBoundary | null;

 /\*\* Timing which user must perform action \_after\_ in order for rule to apply \*/
 @IsNullable()
 @ValidateNested()
 @Type(() => RuleTimeBoundary)
 after: RuleTimeBoundary | null;

 /\*\* Whether or not to apply the rule when the session
 \* interval is wider than the rule's covered time
 \*/
 @IsBoolean()
 partiallyApplicable: boolean;

}
import { IsMilitaryTime, IsNumber, Min } from 'class-validator';

export class RuleTimeBoundary {
 @IsNumber({ maxDecimalPlaces: 0 })
 @Min(0)
 offsetDays: number;

 /\*\* eg HH:MM \*/
 @IsMilitaryTime()
 time: string;
}
```
관련 데이터베이스 유형은 다음과 같습니다:```타입스크립트'class-transformer'에서 { Type }을 임포트합니다;import { IsString, IsNotEmpty, IsNumber, IsPositive, IsEnum, IsArray, ValidateNested,}를 'class-validator'에서 가져옵니다;'../enums/EntityStatus'에서 { EntityStatus }를 임포트합니다;'../enums/PassOfferingInterval'에서 { PassOfferingInterval }을 임포트합니다;'../Model'에서 { staticImplements, StaticModelable, Model }을 임포트합니다;'../types/RecurrenceRule'에서 { RecurrenceRule }을 임포트합니다;'../types/VendDocumentReference'에서 { VendDocumentReference }를 임포트합니다;'../validators/IsNullable'에서 { IsNullable }을 임포트합니다;@staticImplements()export 클래스 PassOffering extends Model { static collectionPath = 'passOfferings'; /\*\* 사람이 읽을 수 있는 패스 이름, 예: "월간 주차권" \*/ @IsString() @IsNotEmpty() 이름: 문자열; @IsNullable() ValidateNested() 유형(() => VendDocumentReference) businessRef: VendDocumentReference | null; /\*\* 예: "1개월"의 "1" \*/ @IsNumber({ maxDecimalPlaces: 0 }) @IsPositive() intervalValue: 숫자; /\*\* 예: "1개월"의 "월" \*/ @IsEnum(PassOfferingInterval) intervalPeriod: PassOfferingInterval; /\*\* \* 간격 내에서 패스를 사용할 수 있는 횟수 \* \* `null` => 무제한 사용 \*/ @IsNullable() @IsNumber({ maxDecimalPlaces: 0 }) @IsPositive() parkLimit: 숫자 | null; /\*\* \* 패스가 가질 수 있는 동시 활성 세션의 최대 수입니다. 플렉스 패스에 사용 \* 한 기업에서 500명의 직원에게 100개의 허용 패스를 배포할 수 있는 경우 \* 선착순으로 배포할 수 있습니다. \* \* `null` => 무제한 사용 \*/ @IsNullable() @IsNumber({ maxDecimalPlaces: 0 }) @IsPositive() 최대 동시 세션: 숫자 | null; @Type(() => RecurrenceRule) IsArray() ValidateNested({ each: true }) 규칙: RecurrenceRule[]; IsEnum(EntityStatus) 상태: EntityStatus;}'class-transformer'에서 { Type }을 임포트합니다;import { IsDate, IsNotEmpty, IsNumber, IsPositive, IsString, ValidateNested,}를 'class-validator'에서 임포트합니다;'../validators/IsNullable'에서 { IsNullable }을 임포트합니다;'./EnterExitRule'에서 { EnterExitRule }을 임포트합니다;export class RecurrenceRule { /\*\* 사용자 항목에 대한 규칙 \*/ @IsNullable() @Type(() => EnterExitRule) @ValidateNested() Enter: EnterExitRule | null; /\*\* 사용자 종료 규칙 \*/ IsNullable() @Type(() => EnterExitRule) ValidateNested() exit: EnterExitRule | null; /\*\* 밀리초 \*/ @IsNullable() @IsNumber({ maxDecimalPlaces: 0 }) @IsPositive() minDuration: 숫자 | null; /\*\* 밀리초 \*/ @IsNullable() @IsNumber({ maxDecimalPlaces: 0 }) @IsPositive() maxDuration: 숫자 | null; // TODO: RRule 유효성 검사 // @IsRRuleSet({ message: 'Not a valid RRuleSet' }) @IsString() @IsNotEmpty() 반복: 문자열;}'class-transformer'에서 { Type }을 임포트합니다;'class-validator'에서 { ValidateNested, IsBoolean }을 임포트합니다;'../validators/IsNullable'에서 { IsNullable }을 임포트합니다;'./RuleTimeBoundary'에서 { RuleTimeBoundary }를 임포트합니다;export class EnterExitRule { /\*\* 규칙이 적용되기 위해 사용자가 \_전에\_ 작업을 수행해야 하는 타이밍 \*/ @IsNullable() @ValidateNested() @Type(() => RuleTimeBoundary) 전에: RuleTimeBoundary | null; /\*\* 규칙이 적용되기 위해 사용자가 \_이후\_에 액션을 수행해야 하는 타이밍 \*/. @IsNullable() @ValidateNested() 유형(() => RuleTimeBoundary) 이후 RuleTimeBoundary | null; /\*\* 세션이 종료될 때 규칙을 적용할지 여부. \* 간격이 규칙의 적용 시간보다 넓을 때 규칙 적용 여부 \*/ @IsBoolean() 부분적으로 적용 가능: 부울;}'class-validator'에서 { IsMilitaryTime, IsNumber, Min }을 가져옵니다;export class RuleTimeBoundary { @IsNumber({ maxDecimalPlaces: 0 }) Min(0) offsetDays: 숫자; /\*\* 예: HH:MM \*/ @IsMilitaryTime() 시간: 문자열;}```