@herd-labs/sdk 0.4.0 → 0.5.1

package/dist/src/live/BookmarksServiceLive.js

@@ -1,5 +1,5 @@
 import { ensureServiceError } from "../errors.js";
-import { BookmarkResponse, BookmarksList } from "../schemas/bookmarks.js";
+import { BookmarkResponseSchema, BookmarksListSchema } from "../schemas/bookmarks.js";
 import { BookmarksService } from "../services/BookmarksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -18,7 +18,7 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedEvents: []
 			},
 			...params.label === void 0 ? {} : { userLabel: params.label }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add contract bookmark"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add contract bookmark"))),
 		addTransaction: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "transaction",
 			transactionHash: params.txHash,
@@ -28,13 +28,13 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedEvents: []
 			},
 			...params.label === void 0 ? {} : { userLabel: params.label }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add transaction bookmark"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add transaction bookmark"))),
 		addWallet: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "wallet",
 			walletAddress: params.address,
 			details: {},
 			...params.label === void 0 ? {} : { userLabel: params.label }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add wallet bookmark"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add wallet bookmark"))),
 		delete: (params) => pipe(client.del(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: params.objectType,
 			...params.address === void 0 ? {} : { contractAddress: params.address },
@@ -42,7 +42,7 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
 			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain }
 		}) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete bookmark"))),
-		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksList)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
+		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksListSchema)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
 		updateLabel: (params) => pipe(client.patch(makeUrl(baseUrl, "/v1/bookmarks/label"), { body: jsonBody({
 			objectType: params.objectType,
 			...params.address === void 0 ? {} : { contractAddress: params.address },
@@ -50,7 +50,7 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
 			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain },
 			userLabel: params.label
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to update bookmark label")))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to update bookmark label")))
 	};
 }));
 

package/dist/src/live/CodeBlocksServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient8 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient2 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CodeBlocksServiceLive.d.ts
-declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfig | effect_unstable_http_HttpClient8.HttpClient>;
+declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfigService | effect_unstable_http_HttpClient2.HttpClient>;
 //#endregion
 export { CodeBlocksServiceLive };

package/dist/src/live/CodeBlocksServiceLive.js

@@ -1,5 +1,5 @@
 import { CodeBlockNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { CodeBlockExecuteResponse, CodeBlocksSearchResponse, CreateCodeBlockResponse, CreateCodeVersionResponse, PublishCodeBlockResponse } from "../schemas/codeblocks.js";
+import { CodeBlockExecuteResponseSchema, CodeBlocksSearchResponseSchema, CreateCodeBlockResponseSchema, CreateCodeVersionResponseSchema, PublishCodeBlockResponseSchema } from "../schemas/codeblocks.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Array, Effect, Layer, Option, pipe } from "effect";
@@ -13,20 +13,20 @@ const mapNotFound = (id) => Effect.catch((error) => {
 const CodeBlocksServiceLive = Layer.effect(CodeBlocksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to create code block"))),
-		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponse)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code block"))),
+		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
 		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId)),
-		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponse)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
+		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponseSchema)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
 		get: (id) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody({
 			scope: "user",
 			limit: 1,
 			filters: { id }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
 			onNone: () => Effect.fail(new CodeBlockNotFoundError({ id })),
 			onSome: Effect.succeed
 		})))),
-		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
+		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
 		updateCode: (definitionId, codeId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code")), mapNotFound(definitionId)),
 		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId))
 	};

package/dist/src/live/CollectionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient9 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient1 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CollectionsServiceLive.d.ts
-declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfig | effect_unstable_http_HttpClient9.HttpClient>;
+declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfigService | effect_unstable_http_HttpClient1.HttpClient>;
 //#endregion
 export { CollectionsServiceLive };

package/dist/src/live/CollectionsServiceLive.js

@@ -1,5 +1,5 @@
 import { CollectionNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { Collection, CollectionsSearchResponse, CreateCollectionResponse } from "../schemas/collections.js";
+import { CollectionSchema, CollectionsSearchResponseSchema, CreateCollectionResponseSchema } from "../schemas/collections.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -13,9 +13,9 @@ const mapNotFound = (id) => Effect.catch((error) => {
 const CollectionsServiceLive = Layer.effect(CollectionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponse)), Effect.mapError(ensureServiceError("Failed to create collection"))),
-		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Collection)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponse)), Effect.mapError(ensureServiceError("Failed to search collections"))),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create collection"))),
+		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionSchema)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search collections"))),
 		update: (collectionId, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/collections/${collectionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update collection")), mapNotFound(collectionId))
 	};
 }));

package/dist/src/live/ContractsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient7 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
 
 //#region src/live/ContractsServiceLive.d.ts
-declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfig | effect_unstable_http_HttpClient7.HttpClient>;
+declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfigService | effect_unstable_http_HttpClient12.HttpClient>;
 //#endregion
 export { ContractsServiceLive };

package/dist/src/live/ContractsServiceLive.js

@@ -1,6 +1,6 @@
 import { ensureServiceError } from "../errors.js";
-import { ContractDiff, ContractMetadata, GetContractCodeResponse } from "../schemas/contracts.js";
-import { DeployedContracts } from "../schemas/wallets.js";
+import { ContractDiffSchema, ContractMetadataSchema, GetContractCodeResponseSchema } from "../schemas/contracts.js";
+import { DeployedContractsSchema } from "../schemas/wallets.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -14,16 +14,16 @@ const ContractsServiceLive = Layer.effect(ContractsService, Effect.gen(function*
 			contractAddress: address,
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiff)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiffSchema)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
 		getContractCode: (blockchain, params) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/code/query"), { body: jsonBody({
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponse)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
-		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponseSchema)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
+		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContractsSchema)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
 		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
 			contractAddress: address,
 			blockchain
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadata)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadataSchema)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
 	};
 }));
 

package/dist/src/live/DocsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { DocsService } from "../services/DocsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
 
 //#region src/live/DocsServiceLive.d.ts
-declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfig | effect_unstable_http_HttpClient11.HttpClient>;
+declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfigService | effect_unstable_http_HttpClient13.HttpClient>;
 //#endregion
 export { DocsServiceLive };

package/dist/src/live/DocsServiceLive.js

@@ -1,5 +1,5 @@
 import { DocNotFoundError, ensureServiceError } from "../errors.js";
-import { DocContent, DocEntry } from "../schemas/docs.js";
+import { DocContentSchema, DocEntrySchema } from "../schemas/docs.js";
 import { DocsService } from "../services/DocsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Schema, pipe } from "effect";
@@ -9,13 +9,13 @@ import { HttpClientResponse } from "effect/unstable/http";
 const DocsServiceLive = Layer.effect(DocsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntry))), Effect.mapError(ensureServiceError("Failed to list docs"))),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntrySchema))), Effect.mapError(ensureServiceError("Failed to list docs"))),
 		read: (docId) => Effect.gen(function* () {
 			const response = yield* pipe(client.get(makeUrl(baseUrl, `/v1/docs/${encodeURIComponent(docId)}`)), Effect.flatMap(checkStatus), Effect.mapError((error) => {
 				const wrapped = ensureServiceError("Failed to read doc")(error);
 				return wrapped.metadata["status"] === 404 ? new DocNotFoundError({ docId }) : wrapped;
 			}));
-			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContent)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
+			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContentSchema)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
 		})
 	};
 }));

package/dist/src/live/DoubleClickServiceLive.d.ts

@@ -0,0 +1,9 @@
+import { HerdConfigService } from "../config.js";
+import { DoubleClickService } from "../services/DoubleClickService.js";
+import { Layer } from "effect";
+import * as effect_unstable_http_HttpClient8 from "effect/unstable/http/HttpClient";
+
+//#region src/live/DoubleClickServiceLive.d.ts
+declare const DoubleClickServiceLive: Layer.Layer<DoubleClickService, never, HerdConfigService | effect_unstable_http_HttpClient8.HttpClient>;
+//#endregion
+export { DoubleClickServiceLive };

package/dist/src/live/DoubleClickServiceLive.js

@@ -0,0 +1,113 @@
+import { ensureServiceError } from "../errors.js";
+import { DoubleClickJsonResponseSchema } from "../schemas/doubleclick.js";
+import { DoubleClickService } from "../services/DoubleClickService.js";
+import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
+import { Effect, Layer, pipe } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
+
+//#region src/live/DoubleClickServiceLive.ts
+const decodeJson = HttpClientResponse.schemaBodyJson(DoubleClickJsonResponseSchema);
+const reviewPath = (target) => `/v1/balance-graph/${target}-versions`;
+const reviewIdsKey = (target) => `${target}VersionIds`;
+const DoubleClickServiceLive = Layer.effect(DoubleClickService, Effect.gen(function* () {
+	const { baseUrl, client } = yield* authorizedClient;
+	const getJson = (path, query, message) => pipe(client.get(makeUrl(baseUrl, path, query)), Effect.flatMap(checkStatus), Effect.flatMap(decodeJson), Effect.mapError(ensureServiceError(message)));
+	const postJson = (path, body, message) => pipe(client.post(makeUrl(baseUrl, path), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(decodeJson), Effect.mapError(ensureServiceError(message)));
+	const postJsonQuery = (path, query, body, message) => pipe(client.post(makeUrl(baseUrl, path, query), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(decodeJson), Effect.mapError(ensureServiceError(message)));
+	const patchJson = (path, body, message) => pipe(client.patch(makeUrl(baseUrl, path), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(decodeJson), Effect.mapError(ensureServiceError(message)));
+	const deleteJson = (path, message) => pipe(client.del(makeUrl(baseUrl, path)), Effect.flatMap(checkStatus), Effect.flatMap(decodeJson), Effect.mapError(ensureServiceError(message)));
+	return {
+		addIssuerToken: (params) => postJson(`/v1/display-tokens/issuers/${params.slug}/add-token`, {
+			nodeId: params.nodeId,
+			order: params.order
+		}, "Failed to add issuer token"),
+		addSlot: (params) => postJson(`/v1/param-queries/slots/${params.targetType}/${params.targetId}`, {
+			slotName: params.slotName,
+			queryId: params.queryId,
+			methodology: params.methodology
+		}, "Failed to add slot"),
+		approveVersion: (params) => patchJson(`${reviewPath(params.target)}/${params.versionId}/approve`, { notes: params.notes }, "Failed to approve graph version"),
+		bulkApproveVersions: (params) => postJson(`${reviewPath(params.target)}/bulk-approve`, {
+			[reviewIdsKey(params.target)]: params.versionIds,
+			notes: params.notes
+		}, "Failed to bulk approve graph versions"),
+		bulkRejectVersions: (params) => postJson(`${reviewPath(params.target)}/bulk-reject`, {
+			[reviewIdsKey(params.target)]: params.versionIds,
+			notes: params.notes
+		}, "Failed to bulk reject graph versions"),
+		convertSlotToFixed: (params) => patchJson(`/v1/param-queries/slots/${params.targetType}/${params.targetId}/${params.slotName}/to-fixed`, {
+			fixedValue: params.fixedValue,
+			methodology: params.methodology
+		}, "Failed to convert slot to fixed"),
+		convertSlotToNotPriced: (params) => patchJson(`/v1/param-queries/slots/${params.targetType}/${params.targetId}/${params.slotName}/to-not-priced`, { methodology: params.methodology }, "Failed to convert slot to not priced"),
+		createIssuer: (params) => postJson("/v1/display-tokens/issuers", params, "Failed to create issuer"),
+		getAssembledNode: (params) => getJson(`/v1/balance-graph/nodes/${params.nodeId}/assembled`, void 0, "Failed to get assembled node"),
+		getIssuer: (slug) => getJson(`/v1/display-tokens/issuers/${slug}`, void 0, "Failed to get issuer"),
+		getLogo: (params) => getJson("/v1/display-tokens/logos", params, "Failed to get logo"),
+		getLogoBatch: (params) => postJson("/v1/display-tokens/logos/batch", params, "Failed to get logo batch"),
+		getLogoBatchMap: (params) => postJson("/v1/display-tokens/logos/batch-map", params, "Failed to get logo batch map"),
+		getNode: (params) => getJson(`/v1/balance-graph/nodes/${params.nodeId}`, {
+			versionOverride: params.versionOverride,
+			adminLive: params.adminLive
+		}, "Failed to get graph node"),
+		getNodeByIdentity: (params) => getJson("/v1/balance-graph/nodes", { identityKey: params.identityKey }, "Failed to get graph node by identity"),
+		getNodeWithCounts: (params) => getJson(`/v1/balance-graph/nodes/${params.nodeId}/with-counts`, { adminLive: params.adminLive }, "Failed to get graph node with counts"),
+		getResearchRun: (runId) => getJson(`/v1/balance-graph-research/runs/${runId}`, void 0, "Failed to get research run"),
+		getResearchRunWithPins: (runId) => getJson(`/v1/balance-graph-research/runs/${runId}/with-pins`, void 0, "Failed to get research run pins"),
+		getTokenByChainAndAddress: (params) => getJson("/v1/display-tokens/tokens", params, "Failed to get token"),
+		getTokenMetrics: (nodeId) => getJson(`/v1/display-tokens/tokens/${nodeId}/metrics`, void 0, "Failed to get token metrics"),
+		getTokenMetricsBatch: (nodeIds) => postJson("/v1/display-tokens/tokens/metrics/batch", { tokenNodeIds: nodeIds }, "Failed to get token metrics"),
+		integrityCheck: (params) => getJson(`/v1/integrity/${params.key}`, { includeDrafts: params.includeDrafts }, "Failed to run integrity check"),
+		integritySummary: (params) => getJson("/v1/integrity/summary", { includeDrafts: params?.includeDrafts }, "Failed to get integrity summary"),
+		listCuratedTokens: (params) => getJson("/v1/display-tokens/curated", params, "Failed to list curated tokens"),
+		listEdgesForNode: (params) => getJson(`/v1/balance-graph/nodes/${params.nodeId}/edges`, { adminLive: params.adminLive }, "Failed to list graph node edges"),
+		listIssuerTokenLinks: getJson("/v1/display-tokens/issuer-token-links", void 0, "Failed to list issuer token links"),
+		listIssuerTokens: (params) => getJson(`/v1/display-tokens/issuers/${params.slug}/tokens`, { include: params.include }, "Failed to list issuer tokens"),
+		listIssuers: getJson("/v1/display-tokens/issuers", void 0, "Failed to list issuers"),
+		listRecentResearchRuns: getJson("/v1/balance-graph-research/runs/recent", void 0, "Failed to list recent research runs"),
+		listRecentResearchRunsWithStats: getJson("/v1/balance-graph-research/runs/recent-with-stats", void 0, "Failed to list recent research runs with stats"),
+		listResearchRunFindings: (runId) => getJson(`/v1/balance-graph-research/runs/${runId}/findings`, void 0, "Failed to list research findings"),
+		listResearchRuns: (params) => getJson("/v1/balance-graph-research/runs", params, "Failed to list research runs"),
+		markResearchRunCompleted: (runId) => postJson(`/v1/balance-graph-research/runs/${runId}/mark-completed`, {}, "Failed to mark research run complete"),
+		markResearchRunFailed: (params) => postJson(`/v1/balance-graph-research/runs/${params.runId}/mark-failed`, { reason: params.reason }, "Failed to mark research run failed"),
+		refreshAllCuratedMetrics: (params = {}) => postJson("/v1/display-tokens/metrics/refresh-all", params, "Failed to refresh all curated metrics"),
+		refreshStaleSlotsForExpansion: (params) => postJson("/v1/param-queries/refresh-stale-slots/expansion", params, "Failed to refresh expansion slots"),
+		refreshStaleSlotsForNode: (params) => postJson(`/v1/param-queries/nodes/${params.nodeId}/refresh-stale-slots`, {
+			staleMs: params.staleMs,
+			adminLive: params.adminLive
+		}, "Failed to refresh node slots"),
+		refreshTokenMetrics: (params) => postJsonQuery(`/v1/display-tokens/tokens/${params.nodeId}/refresh-metrics`, {
+			side: params.side,
+			maxAgeMs: params.maxAgeMs
+		}, {}, "Failed to refresh token metrics"),
+		registerToken: (params) => postJson("/v1/display-tokens/register", params, "Failed to register token"),
+		removeSlot: (params) => deleteJson(`/v1/param-queries/slots/${params.targetType}/${params.targetId}/${params.slotName}`, "Failed to remove slot"),
+		revertVersionToDraft: (params) => patchJson(`${reviewPath(params.target)}/${params.versionId}/revert-to-draft`, {}, "Failed to revert graph version to draft"),
+		runAccountingCheckForNode: (params) => postJson("/v1/accounting-checks/node", params, "Failed to run accounting check"),
+		runAccountingCheckForNodes: (params) => postJson("/v1/accounting-checks/nodes", params, "Failed to run accounting checks"),
+		setCurated: (params) => patchJson(`/v1/display-tokens/${params.nodeId}/curated`, { curated: params.curated }, "Failed to set curated"),
+		setLogo: (params) => patchJson(`/v1/balance-graph/nodes/${params.nodeId}/logo`, { logoUrl: params.logoUrl }, "Failed to set logo"),
+		setPrimaryToken: (params) => postJson(`/v1/display-tokens/${params.nodeId}/set-primary`, { primaryTokenId: params.primaryTokenId }, "Failed to set primary token"),
+		setSlotMethodology: (params) => patchJson(`/v1/param-queries/slots/${params.targetType}/${params.targetId}/${params.slotName}/methodology`, { methodology: params.methodology }, "Failed to set slot methodology"),
+		startResearchRun: (params) => postJson("/v1/balance-graph-research/runs", params, "Failed to start research run"),
+		submitResearchGraph: (params) => postJson(`/v1/balance-graph-research/runs/${params.runId}/graph`, {
+			graph: params.graph,
+			tools: params.tools,
+			status: params.status
+		}, "Failed to submit research graph"),
+		traverseDeep: (params) => postJson("/v1/balance-graph/traversal/deep", params, "Failed to traverse graph"),
+		traverseDirectional: (params) => postJson("/v1/balance-graph/traversal/directional", params, "Failed to traverse directional graph"),
+		updateIssuer: (params) => {
+			const { slug, ...body } = params;
+			return patchJson(`/v1/display-tokens/issuers/${slug}`, body, "Failed to update issuer");
+		},
+		upsertSideMetrics: (params) => postJson(`/v1/display-tokens/tokens/${params.nodeId}/metrics/upsert-side`, {
+			side: params.side,
+			metrics: params.metrics,
+			reason: params.reason
+		}, "Failed to upsert token side metrics")
+	};
+}));
+
+//#endregion
+export { DoubleClickServiceLive };

package/dist/src/live/GroupsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { GroupsService } from "../services/GroupsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient7 from "effect/unstable/http/HttpClient";
 
 //#region src/live/GroupsServiceLive.d.ts
-declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfig | effect_unstable_http_HttpClient12.HttpClient>;
+declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfigService | effect_unstable_http_HttpClient7.HttpClient>;
 //#endregion
 export { GroupsServiceLive };

package/dist/src/live/GroupsServiceLive.js

@@ -1,5 +1,5 @@
 import { ServiceError, ensureServiceError } from "../errors.js";
-import { CreateGroupResponse, EditGroupMetadataResponse, GroupDetails, ListGroupsResponse, ProposalResponse } from "../schemas/groups.js";
+import { CreateGroupResponseSchema, EditGroupMetadataResponseSchema, GroupDetailsSchema, ListGroupsResponseSchema, ProposalResponseSchema } from "../schemas/groups.js";
 import { GroupNotFoundError, GroupsService } from "../services/GroupsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -13,12 +13,12 @@ const mapNotFound = (groupId) => Effect.catch((error) => {
 const GroupsServiceLive = Layer.effect(GroupsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponse)), Effect.mapError(ensureServiceError("Failed to create group"))),
-		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponse)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
-		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetails)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
-		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
-		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
-		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
+		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponseSchema)), Effect.mapError(ensureServiceError("Failed to create group"))),
+		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponseSchema)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
+		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetailsSchema)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponseSchema)), Effect.mapError(ensureServiceError("Failed to list groups"))),
+		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
+		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
 	};
 }));
 

package/dist/src/live/HalServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { HalService } from "../services/HalService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
 
 //#region src/live/HalServiceLive.d.ts
-declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | effect_unstable_http_HttpClient13.HttpClient>;
+declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfigService | effect_unstable_http_HttpClient11.HttpClient>;
 //#endregion
 export { HalServiceLive };

package/dist/src/live/HalServiceLive.js

@@ -1,5 +1,5 @@
 import { ServiceError, SimulationError, ensureServiceError } from "../errors.js";
-import { EvaluateExistingResponse, EvaluateResponse } from "../schemas/hal.js";
+import { EvaluateExistingResponseSchema, EvaluateResponseSchema } from "../schemas/hal.js";
 import { HalService } from "../services/HalService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
@@ -15,8 +15,8 @@ const mapSimulationError = Effect.catch((error) => {
 });
 const HalServiceLive = Layer.effect(HalService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
-	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponse)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
-	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponse)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
+	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
+	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
 	return {
 		evaluate: (params) => callEvaluate({
 			expression: params.expression,

package/dist/src/live/TransactionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient4 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient14 from "effect/unstable/http/HttpClient";
 
 //#region src/live/TransactionsServiceLive.d.ts
-declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfig | effect_unstable_http_HttpClient4.HttpClient>;
+declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfigService | effect_unstable_http_HttpClient14.HttpClient>;
 //#endregion
 export { TransactionsServiceLive };

package/dist/src/live/TransactionsServiceLive.js

@@ -1,5 +1,5 @@
 import { ensureServiceError } from "../errors.js";
-import { LatestEventTransactions, LatestFunctionTransactions, TransactionQueryResponse } from "../schemas/transactions.js";
+import { LatestEventTransactionsSchema, LatestFunctionTransactionsSchema, TransactionQueryResponseSchema } from "../schemas/transactions.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Option, Record, pipe } from "effect";
@@ -31,15 +31,15 @@ const TransactionsServiceLive = Layer.effect(TransactionsService, Effect.gen(fun
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactions)), Effect.mapError(ensureServiceError("Failed to get latest event transactions"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestEventTransactionsSchema)), Effect.mapError(ensureServiceError("Failed to get latest event transactions"))),
 		getLatestFunctionTransactions: (blockchain, address, filter, params) => pipe(client.get(makeUrl(baseUrl, `/v1/contracts/${blockchain}/${address}/latest_function_transactions`, {
 			...latestTxParamsToSnakeCaseQuery(params),
 			...toOptionalQuery({
 				name: filter.name,
 				signature: filter.signature
 			})
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactions)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
-		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponse)), Effect.mapError(ensureServiceError("Failed to get transaction")))
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(LatestFunctionTransactionsSchema)), Effect.mapError(ensureServiceError("Failed to get latest function transactions"))),
+		getTransaction: (blockchain, txHash) => pipe(client.get(makeUrl(baseUrl, `/v1/transactions/${blockchain}/${txHash}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionQueryResponseSchema)), Effect.mapError(ensureServiceError("Failed to get transaction")))
 	};
 }));
 

package/dist/src/live/WalletsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { Layer } from "effect";
-import * as effect_unstable_http_HttpClient5 from "effect/unstable/http/HttpClient";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
 
 //#region src/live/WalletsServiceLive.d.ts
-declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfig | effect_unstable_http_HttpClient5.HttpClient>;
+declare const WalletsServiceLive: Layer.Layer<WalletsService, never, HerdConfigService | effect_unstable_http_HttpClient0.HttpClient>;
 //#endregion
 export { WalletsServiceLive };

package/dist/src/live/WalletsServiceLive.js

@@ -1,5 +1,5 @@
 import { ensureServiceError } from "../errors.js";
-import { DeployedContracts, TokenActivity, TransactionActivity, WalletOverview } from "../schemas/wallets.js";
+import { DeployedContractsSchema, TokenActivitySchema, TransactionActivitySchema, WalletOverviewSchema } from "../schemas/wallets.js";
 import { WalletsService } from "../services/WalletsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, Option, Record, pipe } from "effect";
@@ -15,13 +15,13 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 			after_timestamp: params?.afterTimestamp,
 			before_blocknumber: params?.beforeBlocknumber,
 			after_blocknumber: params?.afterBlocknumber
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContractsSchema)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
 		getOverview: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/overview`, {
 			before_timestamp: params?.beforeTimestamp,
 			after_timestamp: params?.afterTimestamp,
 			before_blocknumber: params?.beforeBlocknumber,
 			after_blocknumber: params?.afterBlocknumber
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WalletOverview)), Effect.mapError(ensureServiceError("Failed to get wallet overview"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WalletOverviewSchema)), Effect.mapError(ensureServiceError("Failed to get wallet overview"))),
 		getTokenActivity: (blockchain, address, tokenAddress, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/tokens/${tokenAddress}`, {
 			page: params?.page,
 			before_timestamp: params?.beforeTimestamp,
@@ -30,7 +30,7 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 			after_blocknumber: params?.afterBlocknumber,
 			from_address: params?.fromAddress,
 			to_address: params?.toAddress
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenActivity)), Effect.mapError(ensureServiceError("Failed to get token activity"))),
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenActivitySchema)), Effect.mapError(ensureServiceError("Failed to get token activity"))),
 		getTransactions: (query) => {
 			const optionalFields = Record.getSomes(Record.map({
 				from_address: query.fromAddress,
@@ -45,7 +45,7 @@ const WalletsServiceLive = Layer.effect(WalletsService, Effect.gen(function* ()
 				blockchain: query.blockchain,
 				page: query.page ?? 1,
 				...optionalFields
-			}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionActivity)), Effect.mapError(ensureServiceError("Failed to get wallet transactions")));
+			}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TransactionActivitySchema)), Effect.mapError(ensureServiceError("Failed to get wallet transactions")));
 		}
 	};
 }));

package/dist/src/live/http.d.ts

@@ -1,4 +1,4 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ServiceError } from "../errors.js";
 import { Effect, Schema } from "effect";
 import { HttpBody, HttpClient, HttpClientResponse, UrlParams } from "effect/unstable/http";
@@ -9,7 +9,7 @@ declare const makeUrl: (baseUrl: string, path: string, queryParams?: object) =>
 declare const authorizedClient: Effect.Effect<{
   baseUrl: string;
   client: HttpClient.HttpClient.With<effect_unstable_http_HttpClientError0.HttpClientError, never>;
-}, never, HerdConfig | HttpClient.HttpClient>;
+}, never, HerdConfigService | HttpClient.HttpClient>;
 declare const handleJsonResponse: <S extends Schema.Top>(schema: S) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<S["Type"], ServiceError, S["DecodingServices"]>;
 declare const checkStatus: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<HttpClientResponse.HttpClientResponse, ServiceError>;
 declare const jsonBody: (body: unknown) => HttpBody.HttpBody;

package/dist/src/live/http.js

@@ -1,4 +1,4 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ServiceError } from "../errors.js";
 import { Effect, Function, Result, pipe } from "effect";
 import { HttpBody, HttpClient, HttpClientRequest, HttpClientResponse, UrlParams } from "effect/unstable/http";
@@ -13,7 +13,7 @@ const makeUrl = (baseUrl, path, queryParams) => {
 	return url.toString();
 };
 const authorizedClient = Effect.gen(function* () {
-	const config = yield* HerdConfig;
+	const config = yield* HerdConfigService;
 	const client = yield* HttpClient.HttpClient;
 	const { baseUrl, authHeaders } = Result.match(config, {
 		onFailure: ({ baseUrl: innerBaseUrl, oauthAccessToken }) => ({