@relayfx/sdk 0.3.7 → 0.4.1

package/dist/types/runtime/resident/resident-instance-service.d.ts

@@ -0,0 +1,76 @@
+import { Content, Ids, Resident, Shared } from "../../schema/index";
+import { ResidentRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as AddressBookService } from "../address/address-book-service";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { ResidentKindInvalid, ResidentKindNotFound, Service as ResidentRegistryService } from "./resident-registry-service";
+declare const ResidentDestroyed_base: Schema.Class<ResidentDestroyed, Schema.TaggedStruct<"ResidentDestroyed", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentDestroyed extends ResidentDestroyed_base {
+}
+declare const ResidentNotFound_base: Schema.Class<ResidentNotFound, Schema.TaggedStruct<"ResidentNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentNotFound extends ResidentNotFound_base {
+}
+declare const ResidentServiceError_base: Schema.Class<ResidentServiceError, Schema.TaggedStruct<"ResidentServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentServiceError extends ResidentServiceError_base {
+}
+export interface SpawnInput {
+    readonly kind: Ids.ResidentKindName;
+    readonly key: Ids.ResidentKey;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly spawn: (input: SpawnInput) => Effect.Effect<Resident.Instance, ResidentKindNotFound | ResidentKindInvalid | ResidentServiceError>;
+    readonly get: (input: {
+        readonly kind: Ids.ResidentKindName;
+        readonly key: Ids.ResidentKey;
+    }) => Effect.Effect<Resident.Instance | undefined, ResidentServiceError>;
+    readonly destroy: (input: {
+        readonly kind: Ids.ResidentKindName;
+        readonly key: Ids.ResidentKey;
+        readonly reason?: string;
+        readonly destroyedAt: number;
+    }) => Effect.Effect<Resident.Instance, ResidentNotFound | ResidentDestroyed | ResidentServiceError>;
+    readonly list: (input: {
+        readonly kind?: Ids.ResidentKindName;
+        readonly afterKind?: Ids.ResidentKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Resident.Instance>, ResidentServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/resident/resident-instance-service/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const residentExecutionId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey, generation: number): Ids.ExecutionId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey, generation: number): (tenant: Ids.TenantId) => Ids.ExecutionId;
+};
+export declare const residentAddressId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey): Ids.AddressId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey): (tenant: Ids.TenantId) => Ids.AddressId;
+};
+export declare const residentSessionId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey): Ids.SessionId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey): (tenant: Ids.TenantId) => Ids.SessionId;
+};
+export declare const layer: Layer.Layer<Service, never, ResidentRepository.Service | AddressBookService | EventLogService | AgentRegistryService | ResidentRegistryService | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/resident/resident-registry-service.d.ts

@@ -0,0 +1,35 @@
+import { Ids, Resident } from "../../schema/index";
+import { ResidentRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
+declare const ResidentKindNotFound_base: Schema.Class<ResidentKindNotFound, Schema.TaggedStruct<"ResidentKindNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentKindNotFound extends ResidentKindNotFound_base {
+}
+declare const ResidentKindInvalid_base: Schema.Class<ResidentKindInvalid, Schema.TaggedStruct<"ResidentKindInvalid", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentKindInvalid extends ResidentKindInvalid_base {
+}
+declare const ResidentRegistryError_base: Schema.Class<ResidentRegistryError, Schema.TaggedStruct<"ResidentRegistryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentRegistryError extends ResidentRegistryError_base {
+}
+export interface Interface {
+    readonly registerKind: (input: Resident.KindDefinition) => Effect.Effect<Resident.KindDefinition, ResidentKindInvalid | ResidentRegistryError>;
+    readonly getKind: (kind: Ids.ResidentKindName) => Effect.Effect<Resident.KindDefinition | undefined, ResidentRegistryError>;
+    readonly listKinds: Effect.Effect<ReadonlyArray<Resident.KindDefinition>, ResidentRegistryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/resident/resident-registry-service/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, ResidentRepository.Service | AgentRegistryService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};