@sjunepark/landprice 0.0.2 → 0.0.3

package/README.md

@@ -35,7 +35,7 @@ landprice search-individual-land-prices --years 2026,2025,2024 --district-code 4
 landprice <command> --help
 ```
 
-명령 성공은 표준 출력에 하나의 JSON 응답 객체로 출력됩니다. 명령 실패는 표준 에러에 JSON 실패 객체를 출력하고 0이 아닌 종료 코드로 끝납니다. 도움말 출력은 사람이 읽기 쉬운 텍스트로 유지됩니다.
+명령 성공은 표준 출력에 하나의 JSON 응답 객체로 출력됩니다. 명령 실패도 표준 출력에 하나의 JSON 실패 객체를 출력하고 0이 아닌 종료 코드로 끝납니다. 도움말 출력은 사람이 읽기 쉬운 텍스트로 유지됩니다.
 
 현재 제공하는 주요 작업은 다음과 같습니다.
 
@@ -74,7 +74,7 @@ landprice get-standard-land-price-detail --reference '{"year":2026,"regCode":"11
 
 명령 추가, 선택 입력 필드 추가, 결과 필드 추가, 경고나 메타데이터 추가는 호환 가능한 변경입니다.
 
-현재 표준 통합 지점은 CLI입니다. 별도의 패키지 API, Pi 어댑터, MCP 서버는 아직 공개 계약으로 제공하지 않습니다.
+표준 통합 지점은 CLI, 런타임 중립 TypeScript toolset, Pi 어댑터입니다. toolset은 `@sjunepark/landprice/toolset`에서, Pi 어댑터는 `@sjunepark/landprice/pi`에서 가져올 수 있습니다. MCP 서버는 공개 계약으로 제공하지 않습니다.
 
 ## 주의사항
 
@@ -95,6 +95,9 @@ bun run typecheck
 bun test
 bun run build
 node dist/cli.js get-available-years
+
+# Package surfaces after build
+node -e "import('./dist/toolset.js').then(({ createLandpriceToolset }) => console.log(createLandpriceToolset().listOperations().length))"
 ```
 
 릴리스 자동화와 필요한 저장소 설정은 [docs/release.md](docs/release.md)를 참고하세요.

package/dist/app/get-available-years.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type GetAvailableYearsResult } from "../capabilities/get-available-years/contract.ts";
+import type { GetAvailableYearsProvider } from "../capabilities/get-available-years/provider.ts";
+export declare const getAvailableYearsOperationName: "get-available-years";
+export declare const getAvailableYearsInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const getAvailableYearsResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type GetAvailableYearsOperation = {
+    readonly name: typeof getAvailableYearsOperationName;
+    readonly inputJsonSchema: typeof getAvailableYearsInputJsonSchema;
+    readonly resultJsonSchema: typeof getAvailableYearsResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;
+};
+export declare const createGetAvailableYearsOperation: (provider: GetAvailableYearsProvider) => GetAvailableYearsOperation;
+export declare const defaultGetAvailableYearsOperation: GetAvailableYearsOperation;

package/dist/app/get-standard-land-price-detail.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type GetStandardLandPriceDetailResult } from "../capabilities/get-standard-land-price-detail/contract.ts";
+import type { GetStandardLandPriceDetailProvider } from "../capabilities/get-standard-land-price-detail/provider.ts";
+export declare const getStandardLandPriceDetailOperationName: "get-standard-land-price-detail";
+export declare const getStandardLandPriceDetailInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const getStandardLandPriceDetailResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type GetStandardLandPriceDetailOperation = {
+    readonly name: typeof getStandardLandPriceDetailOperationName;
+    readonly inputJsonSchema: typeof getStandardLandPriceDetailInputJsonSchema;
+    readonly resultJsonSchema: typeof getStandardLandPriceDetailResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;
+};
+export declare const createGetStandardLandPriceDetailOperation: (provider: GetStandardLandPriceDetailProvider) => GetStandardLandPriceDetailOperation;
+export declare const defaultGetStandardLandPriceDetailOperation: GetStandardLandPriceDetailOperation;

package/dist/app/list-areas.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type ListAreasResult } from "../capabilities/list-areas/contract.ts";
+import type { ListAreasProvider } from "../capabilities/list-areas/provider.ts";
+export declare const listAreasOperationName: "list-areas";
+export declare const listAreasInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const listAreasResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type ListAreasOperation = {
+    readonly name: typeof listAreasOperationName;
+    readonly inputJsonSchema: typeof listAreasInputJsonSchema;
+    readonly resultJsonSchema: typeof listAreasResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<ListAreasResult>;
+};
+export declare const createListAreasOperation: (provider: ListAreasProvider) => ListAreasOperation;
+export declare const defaultListAreasOperation: ListAreasOperation;

package/dist/app/search-individual-land-prices.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type SearchIndividualLandPricesResult } from "../capabilities/search-individual-land-prices/contract.ts";
+import type { SearchIndividualLandPricesProvider } from "../capabilities/search-individual-land-prices/provider.ts";
+export declare const searchIndividualLandPricesOperationName: "search-individual-land-prices";
+export declare const searchIndividualLandPricesInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const searchIndividualLandPricesResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type SearchIndividualLandPricesOperation = {
+    readonly name: typeof searchIndividualLandPricesOperationName;
+    readonly inputJsonSchema: typeof searchIndividualLandPricesInputJsonSchema;
+    readonly resultJsonSchema: typeof searchIndividualLandPricesResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<SearchIndividualLandPricesResult>;
+};
+export declare const createSearchIndividualLandPricesOperation: (provider: SearchIndividualLandPricesProvider) => SearchIndividualLandPricesOperation;
+export declare const defaultSearchIndividualLandPricesOperation: SearchIndividualLandPricesOperation;

package/dist/app/search-standard-land-prices.d.ts

@@ -0,0 +1,14 @@
+import { type ToolRunContext } from "../capabilities/types.ts";
+import { type SearchStandardLandPricesResult } from "../capabilities/search-standard-land-prices/contract.ts";
+import type { SearchStandardLandPricesProvider } from "../capabilities/search-standard-land-prices/provider.ts";
+export declare const searchStandardLandPricesOperationName: "search-standard-land-prices";
+export declare const searchStandardLandPricesInputJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export declare const searchStandardLandPricesResultJsonSchema: import("effect/JSONSchema").JsonSchema7Root;
+export type SearchStandardLandPricesOperation = {
+    readonly name: typeof searchStandardLandPricesOperationName;
+    readonly inputJsonSchema: typeof searchStandardLandPricesInputJsonSchema;
+    readonly resultJsonSchema: typeof searchStandardLandPricesResultJsonSchema;
+    readonly execute: (input: Record<string, unknown>, context?: ToolRunContext) => Promise<SearchStandardLandPricesResult>;
+};
+export declare const createSearchStandardLandPricesOperation: (provider: SearchStandardLandPricesProvider) => SearchStandardLandPricesOperation;
+export declare const defaultSearchStandardLandPricesOperation: SearchStandardLandPricesOperation;

package/dist/capabilities/get-available-years/contract.d.ts

@@ -0,0 +1,78 @@
+import { Schema } from "effect";
+import { type SuccessEnvelope } from "../types.ts";
+export declare const GetAvailableYearsInputSchema: Schema.Struct<{
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type GetAvailableYearsRawInput = typeof GetAvailableYearsInputSchema.Encoded;
+export declare const YearRangeSchema: Schema.Struct<{
+    startYear: typeof Schema.Int;
+    endYear: typeof Schema.Int;
+    years: Schema.Array$<typeof Schema.Int>;
+}>;
+export type YearRange = typeof YearRangeSchema.Type;
+export declare const GetAvailableYearsResultPayloadSchema: Schema.Struct<{
+    standardLandSearchYears: Schema.Struct<{
+        startYear: typeof Schema.Int;
+        endYear: typeof Schema.Int;
+        years: Schema.Array$<typeof Schema.Int>;
+    }>;
+    noticeDateSearchYears: Schema.Struct<{
+        startYear: typeof Schema.Int;
+        endYear: typeof Schema.Int;
+        years: Schema.Array$<typeof Schema.Int>;
+    }>;
+    sourceObserved: typeof Schema.Boolean;
+    raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+}>;
+export type GetAvailableYearsResultPayload = typeof GetAvailableYearsResultPayloadSchema.Type;
+export declare const GetAvailableYearsResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        standardLandSearchYears: Schema.Struct<{
+            startYear: typeof Schema.Int;
+            endYear: typeof Schema.Int;
+            years: Schema.Array$<typeof Schema.Int>;
+        }>;
+        noticeDateSearchYears: Schema.Struct<{
+            startYear: typeof Schema.Int;
+            endYear: typeof Schema.Int;
+            years: Schema.Array$<typeof Schema.Int>;
+        }>;
+        sourceObserved: typeof Schema.Boolean;
+        raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type GetAvailableYearsResult = SuccessEnvelope<GetAvailableYearsResultPayload>;

package/dist/capabilities/get-available-years/execute.d.ts

@@ -0,0 +1,7 @@
+import { type ResponseDetail, type ToolRunContext } from "../types.ts";
+import type { GetAvailableYearsResult } from "./contract.ts";
+import type { GetAvailableYearsProvider } from "./provider.ts";
+export declare const resolveGetAvailableYearsRequest: (input: Record<string, unknown>) => {
+    readonly responseDetail: ResponseDetail;
+};
+export declare const executeGetAvailableYears: (input: Record<string, unknown>, provider: GetAvailableYearsProvider, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;

package/dist/capabilities/get-available-years/provider.d.ts

@@ -0,0 +1,7 @@
+import type { ResponseDetail, ToolRunContext } from "../types.ts";
+import type { GetAvailableYearsResult } from "./contract.ts";
+export type GetAvailableYearsProvider = {
+    readonly getAvailableYears: (request: {
+        readonly responseDetail: ResponseDetail;
+    }, context?: ToolRunContext) => Promise<GetAvailableYearsResult>;
+};

package/dist/capabilities/get-standard-land-price-detail/contract.d.ts

@@ -0,0 +1,152 @@
+import { Schema } from "effect";
+import { type ResponseDetail, type StandardLandReference, type SuccessEnvelope } from "../types.ts";
+export declare const GetStandardLandPriceDetailInputSchema: Schema.Struct<{
+    standardLandReference: Schema.Struct<{
+        year: Schema.refine<number, typeof Schema.Number>;
+        regCode: Schema.SchemaClass<string, string, never>;
+        eubCode: Schema.SchemaClass<string, string, never>;
+        sourceSanFlag: Schema.SchemaClass<string, string, never>;
+        bun1: Schema.SchemaClass<string, string, never>;
+        bun2: Schema.SchemaClass<string, string, never>;
+        standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    }>;
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type GetStandardLandPriceDetailRawInput = typeof GetStandardLandPriceDetailInputSchema.Encoded;
+export type GetStandardLandPriceDetailRequest = {
+    readonly standardLandReference: StandardLandReference;
+    readonly responseDetail: ResponseDetail;
+};
+export declare const ReferencePriceDataSchema: Schema.Struct<{
+    kind: Schema.NullOr<typeof Schema.String>;
+    address: Schema.NullOr<typeof Schema.String>;
+    zoning: Schema.NullOr<typeof Schema.String>;
+    landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+    buildingYear: Schema.NullOr<typeof Schema.String>;
+    buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+    date: Schema.NullOr<typeof Schema.String>;
+    priceDisplay: Schema.NullOr<typeof Schema.String>;
+}>;
+export type ReferencePriceData = typeof ReferencePriceDataSchema.Type;
+export declare const StandardLandPriceDetailSchema: Schema.Struct<{
+    standardLandReference: Schema.Struct<{
+        year: Schema.refine<number, typeof Schema.Number>;
+        regCode: Schema.SchemaClass<string, string, never>;
+        eubCode: Schema.SchemaClass<string, string, never>;
+        sourceSanFlag: Schema.SchemaClass<string, string, never>;
+        bun1: Schema.SchemaClass<string, string, never>;
+        bun2: Schema.SchemaClass<string, string, never>;
+        standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    }>;
+    address: Schema.NullOr<typeof Schema.String>;
+    roadAddress: Schema.NullOr<typeof Schema.String>;
+    areaSquareMeters: Schema.optional<typeof Schema.Number>;
+    areaDisplay: Schema.NullOr<typeof Schema.String>;
+    previousOfficialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+    officialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+    locationDescription: Schema.NullOr<typeof Schema.String>;
+    surroundingEnvironment: Schema.NullOr<typeof Schema.String>;
+    landCategory: Schema.NullOr<typeof Schema.String>;
+    zoning: Schema.NullOr<typeof Schema.String>;
+    district: Schema.NullOr<typeof Schema.String>;
+    planningFacility: Schema.NullOr<typeof Schema.String>;
+    constraintRatio: Schema.NullOr<typeof Schema.String>;
+    roadFrontage: Schema.NullOr<typeof Schema.String>;
+    shape: Schema.NullOr<typeof Schema.String>;
+    elevation: Schema.NullOr<typeof Schema.String>;
+    useStatus: Schema.NullOr<typeof Schema.String>;
+    representativeParcel: Schema.optional<typeof Schema.Boolean>;
+    hazardAccess: Schema.NullOr<typeof Schema.String>;
+    referencePriceData: Schema.Struct<{
+        kind: Schema.NullOr<typeof Schema.String>;
+        address: Schema.NullOr<typeof Schema.String>;
+        zoning: Schema.NullOr<typeof Schema.String>;
+        landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+        buildingYear: Schema.NullOr<typeof Schema.String>;
+        buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+        date: Schema.NullOr<typeof Schema.String>;
+        priceDisplay: Schema.NullOr<typeof Schema.String>;
+    }>;
+    valuationOpinion: Schema.NullOr<typeof Schema.String>;
+    raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+}>;
+export type StandardLandPriceDetail = typeof StandardLandPriceDetailSchema.Type;
+export declare const GetStandardLandPriceDetailResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        standardLandReference: Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>;
+        address: Schema.NullOr<typeof Schema.String>;
+        roadAddress: Schema.NullOr<typeof Schema.String>;
+        areaSquareMeters: Schema.optional<typeof Schema.Number>;
+        areaDisplay: Schema.NullOr<typeof Schema.String>;
+        previousOfficialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+        officialPricePerSquareMeter: Schema.optional<typeof Schema.Number>;
+        locationDescription: Schema.NullOr<typeof Schema.String>;
+        surroundingEnvironment: Schema.NullOr<typeof Schema.String>;
+        landCategory: Schema.NullOr<typeof Schema.String>;
+        zoning: Schema.NullOr<typeof Schema.String>;
+        district: Schema.NullOr<typeof Schema.String>;
+        planningFacility: Schema.NullOr<typeof Schema.String>;
+        constraintRatio: Schema.NullOr<typeof Schema.String>;
+        roadFrontage: Schema.NullOr<typeof Schema.String>;
+        shape: Schema.NullOr<typeof Schema.String>;
+        elevation: Schema.NullOr<typeof Schema.String>;
+        useStatus: Schema.NullOr<typeof Schema.String>;
+        representativeParcel: Schema.optional<typeof Schema.Boolean>;
+        hazardAccess: Schema.NullOr<typeof Schema.String>;
+        referencePriceData: Schema.Struct<{
+            kind: Schema.NullOr<typeof Schema.String>;
+            address: Schema.NullOr<typeof Schema.String>;
+            zoning: Schema.NullOr<typeof Schema.String>;
+            landAreaDisplay: Schema.NullOr<typeof Schema.String>;
+            buildingYear: Schema.NullOr<typeof Schema.String>;
+            buildingAreaDisplay: Schema.NullOr<typeof Schema.String>;
+            date: Schema.NullOr<typeof Schema.String>;
+            priceDisplay: Schema.NullOr<typeof Schema.String>;
+        }>;
+        valuationOpinion: Schema.NullOr<typeof Schema.String>;
+        raw: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type GetStandardLandPriceDetailResult = SuccessEnvelope<StandardLandPriceDetail>;

package/dist/capabilities/get-standard-land-price-detail/execute.d.ts

@@ -0,0 +1,5 @@
+import { type ToolRunContext } from "../types.ts";
+import type { GetStandardLandPriceDetailRequest, GetStandardLandPriceDetailResult } from "./contract.ts";
+import type { GetStandardLandPriceDetailProvider } from "./provider.ts";
+export declare const resolveGetStandardLandPriceDetailRequest: (input: Record<string, unknown>) => GetStandardLandPriceDetailRequest;
+export declare const executeGetStandardLandPriceDetail: (input: Record<string, unknown>, provider: GetStandardLandPriceDetailProvider, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;

package/dist/capabilities/get-standard-land-price-detail/provider.d.ts

@@ -0,0 +1,5 @@
+import type { ToolRunContext } from "../types.ts";
+import type { GetStandardLandPriceDetailRequest, GetStandardLandPriceDetailResult } from "./contract.ts";
+export type GetStandardLandPriceDetailProvider = {
+    readonly getStandardLandPriceDetail: (request: GetStandardLandPriceDetailRequest, context?: ToolRunContext) => Promise<GetStandardLandPriceDetailResult>;
+};

package/dist/capabilities/list-areas/contract.d.ts

@@ -0,0 +1,106 @@
+import { Schema } from "effect";
+import { type AreaLevel, type AreaSurface, type ResponseDetail, type SearchMode, type SuccessEnvelope } from "../types.ts";
+export declare const ListAreasInputSchema: Schema.Struct<{
+    year: typeof Schema.Int;
+    searchMode: Schema.optional<Schema.Literal<["current-address", "notice-date"]>>;
+    surface: Schema.optional<Schema.Literal<["standard-land", "individual-land"]>>;
+    level: Schema.Literal<["sido", "district", "legal-dong"]>;
+    sidoCode: Schema.optional<typeof Schema.String>;
+    districtCode: Schema.optional<typeof Schema.String>;
+    responseDetail: Schema.optional<Schema.Literal<["concise", "raw"]>>;
+}>;
+export type ListAreasRawInput = typeof ListAreasInputSchema.Encoded;
+export type ListAreasRequest = {
+    readonly year: number;
+    readonly searchMode: SearchMode;
+    readonly surface: AreaSurface;
+    readonly level: AreaLevel;
+    readonly sidoCode?: string;
+    readonly districtCode?: string;
+    readonly responseDetail: ResponseDetail;
+};
+export declare const AreaSchema: Schema.Struct<{
+    code: typeof Schema.String;
+    name: typeof Schema.String;
+    sidoCode: Schema.optional<typeof Schema.String>;
+    districtCode: Schema.optional<typeof Schema.String>;
+    legalDongCode: Schema.optional<typeof Schema.String>;
+    source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+}>;
+export type Area = typeof AreaSchema.Type;
+export declare const ListAreasResultPayloadSchema: Schema.Struct<{
+    year: typeof Schema.Int;
+    searchMode: Schema.Literal<["current-address", "notice-date"]>;
+    surface: Schema.Literal<["standard-land", "individual-land"]>;
+    level: Schema.Literal<["sido", "district", "legal-dong"]>;
+    parent: Schema.Struct<{
+        sidoCode: Schema.optional<typeof Schema.String>;
+        districtCode: Schema.optional<typeof Schema.String>;
+    }>;
+    areas: Schema.Array$<Schema.Struct<{
+        code: typeof Schema.String;
+        name: typeof Schema.String;
+        sidoCode: Schema.optional<typeof Schema.String>;
+        districtCode: Schema.optional<typeof Schema.String>;
+        legalDongCode: Schema.optional<typeof Schema.String>;
+        source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+    }>>;
+    raw: Schema.optional<typeof Schema.Any>;
+}>;
+export type ListAreasResultPayload = typeof ListAreasResultPayloadSchema.Type;
+export declare const ListAreasResultSchema: Schema.Struct<{
+    result: Schema.Struct<{
+        year: typeof Schema.Int;
+        searchMode: Schema.Literal<["current-address", "notice-date"]>;
+        surface: Schema.Literal<["standard-land", "individual-land"]>;
+        level: Schema.Literal<["sido", "district", "legal-dong"]>;
+        parent: Schema.Struct<{
+            sidoCode: Schema.optional<typeof Schema.String>;
+            districtCode: Schema.optional<typeof Schema.String>;
+        }>;
+        areas: Schema.Array$<Schema.Struct<{
+            code: typeof Schema.String;
+            name: typeof Schema.String;
+            sidoCode: Schema.optional<typeof Schema.String>;
+            districtCode: Schema.optional<typeof Schema.String>;
+            legalDongCode: Schema.optional<typeof Schema.String>;
+            source: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+        }>>;
+        raw: Schema.optional<typeof Schema.Any>;
+    }>;
+    metadata: Schema.Struct<{
+        sourceSystem: Schema.Literal<["realtyprice"]>;
+        sourcePage: Schema.Literal<["https://www.realtyprice.kr/notice/gsstandard/search.htm", "https://www.realtyprice.kr/notice/gsindividual/search.htm"]>;
+        endpoint: typeof Schema.String;
+        query: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Any>>;
+        retrievedAt: typeof Schema.String;
+        completeness: Schema.Literal<["complete", "empty", "partial", "unknown"]>;
+        sourceBehavior: typeof Schema.String;
+    }>;
+    references: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["sourcePage", "endpoint", "area", "standardLandRecord", "individualLandRecord", "detail"]>;
+        sourceUrl: typeof Schema.String;
+        standardLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+            standardLandNumber: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        }>>;
+        individualLandReference: Schema.optional<Schema.Struct<{
+            year: Schema.refine<number, typeof Schema.Number>;
+            regCode: Schema.SchemaClass<string, string, never>;
+            eubCode: Schema.SchemaClass<string, string, never>;
+            sourceSanFlag: Schema.SchemaClass<string, string, never>;
+            bun1: Schema.SchemaClass<string, string, never>;
+            bun2: Schema.SchemaClass<string, string, never>;
+        }>>;
+    }>>;
+    warnings: Schema.Array$<Schema.Union<[typeof Schema.String, Schema.Struct<{
+        code: typeof Schema.String;
+        message: typeof Schema.String;
+    }>]>>;
+}>;
+export type ListAreasResult = SuccessEnvelope<ListAreasResultPayload>;

package/dist/capabilities/list-areas/execute.d.ts

@@ -0,0 +1,5 @@
+import { type ToolRunContext } from "../types.ts";
+import type { ListAreasRequest, ListAreasResult } from "./contract.ts";
+import type { ListAreasProvider } from "./provider.ts";
+export declare const resolveListAreasRequest: (input: Record<string, unknown>) => ListAreasRequest;
+export declare const executeListAreas: (input: Record<string, unknown>, provider: ListAreasProvider, context?: ToolRunContext) => Promise<ListAreasResult>;

package/dist/capabilities/list-areas/provider.d.ts

@@ -0,0 +1,5 @@
+import type { ToolRunContext } from "../types.ts";
+import type { ListAreasRequest, ListAreasResult } from "./contract.ts";
+export type ListAreasProvider = {
+    readonly listAreas: (request: ListAreasRequest, context?: ToolRunContext) => Promise<ListAreasResult>;
+};

package/dist/capabilities/request-validation.d.ts

@@ -0,0 +1,14 @@
+import { type AreaLevel, type AreaSurface, type ResponseDetail, type SearchMode } from "./types.ts";
+export declare function assertObjectInput(input: unknown): asserts input is Record<string, unknown>;
+export declare const assertNoUnknownKeys: (input: Record<string, unknown>, allowedKeys: ReadonlySet<string>) => void;
+export declare const readOptionalResponseDetail: (input: Record<string, unknown>) => ResponseDetail;
+export declare const readOptionalSearchMode: (input: Record<string, unknown>) => SearchMode;
+export declare const readOptionalAreaSurface: (input: Record<string, unknown>) => AreaSurface;
+export declare const readRequiredAreaLevel: (input: Record<string, unknown>) => AreaLevel;
+export declare const readRequiredInteger: (input: Record<string, unknown>, key: string) => number;
+export declare const readOptionalInteger: (input: Record<string, unknown>, key: string, defaultValue: number) => number;
+export declare const readOptionalIntegerArray: (input: Record<string, unknown>, key: string) => readonly number[] | undefined;
+export declare const readOptionalString: (input: Record<string, unknown>, key: string) => string | undefined;
+export declare const readRequiredString: (input: Record<string, unknown>, key: string) => string;
+export declare const assertDigits: (key: string, value: string, length: number) => void;
+export declare const assertMinInteger: (key: string, value: number, min: number) => void;