samva 0.15.0 → 0.17.0

package/dist/operations-CmB3FHwf.js

@@ -0,0 +1,93 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { At as OperationAccepted, D as Cursor, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Y as InternalError, en as ValidationError, jt as OperationId, kt as Operation, m as ConflictError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/operations.ts
+const OperationPage = /* @__PURE__ */ Schema.Struct({
+	items: Schema.Array(Operation),
+	nextCursor: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "OperationPage" });
+const OperationsListQuery = /* @__PURE__ */ Schema.Struct({
+	limit: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	cursor: Schema.optionalKey(Schema.Union([Cursor, Schema.Null])),
+	kind: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Literal("email-domain-provisioning"), Schema.Literal("organization-deletion")]), Schema.Null])),
+	status: Schema.optionalKey(Schema.Union([Schema.Union([
+		Schema.Literal("pending"),
+		Schema.Literal("running"),
+		Schema.Literal("succeeded"),
+		Schema.Literal("failed")
+	]), Schema.Null]))
+});
+const OperationsList200 = OperationPage;
+const OperationsList401 = UnauthorizedError;
+const OperationsList403 = ForbiddenError;
+const OperationsList422 = ValidationError;
+const OperationsList500 = InternalError;
+const OperationsList504 = GatewayTimeoutError;
+const OperationsGetPathParams = /* @__PURE__ */ Schema.Struct({ id: OperationId });
+const OperationsGet200 = Operation;
+const OperationsGet401 = UnauthorizedError;
+const OperationsGet403 = ForbiddenError;
+const OperationsGet404 = ResourceNotFoundError;
+const OperationsGet422 = ValidationError;
+const OperationsGet500 = InternalError;
+const OperationsGet504 = GatewayTimeoutError;
+const OperationsRetryPathParams = /* @__PURE__ */ Schema.Struct({ id: OperationId });
+const OperationsRetry202 = OperationAccepted;
+const OperationsRetry401 = UnauthorizedError;
+const OperationsRetry403 = ForbiddenError;
+const OperationsRetry404 = ResourceNotFoundError;
+const OperationsRetry409 = ConflictError;
+const OperationsRetry422 = ValidationError;
+const OperationsRetry500 = InternalError;
+const OperationsRetry504 = GatewayTimeoutError;
+var OperationsGroup = class extends HttpApiGroup.make("Operations").add(HttpApiEndpoint.get("operationsList", "/v1/operations", {
+	query: OperationsListQuery,
+	success: OperationsList200,
+	error: [
+		OperationsList401.pipe(HttpApiSchema.status(401)),
+		OperationsList403.pipe(HttpApiSchema.status(403)),
+		OperationsList422.pipe(HttpApiSchema.status(422)),
+		OperationsList500,
+		OperationsList504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.list").annotate(OpenApi.Summary, "List asynchronous operations").annotate(OpenApi.Description, "Lists asynchronous operations for the active organization, newest first. Pass `nextCursor` back as `cursor` for the next page; it is null on the last page."), HttpApiEndpoint.get("operationsGet", "/v1/operations/:id", {
+	params: OperationsGetPathParams,
+	success: OperationsGet200,
+	error: [
+		OperationsGet401.pipe(HttpApiSchema.status(401)),
+		OperationsGet403.pipe(HttpApiSchema.status(403)),
+		OperationsGet404.pipe(HttpApiSchema.status(404)),
+		OperationsGet422.pipe(HttpApiSchema.status(422)),
+		OperationsGet500,
+		OperationsGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.get").annotate(OpenApi.Summary, "Get an asynchronous operation").annotate(OpenApi.Description, "Returns one asynchronous operation from the active organization."), HttpApiEndpoint.post("operationsRetry", "/v1/operations/:id/retry", {
+	params: OperationsRetryPathParams,
+	success: OperationsRetry202.pipe(HttpApiSchema.status(202)),
+	error: [
+		OperationsRetry401.pipe(HttpApiSchema.status(401)),
+		OperationsRetry403.pipe(HttpApiSchema.status(403)),
+		OperationsRetry404.pipe(HttpApiSchema.status(404)),
+		OperationsRetry409.pipe(HttpApiSchema.status(409)),
+		OperationsRetry422.pipe(HttpApiSchema.status(422)),
+		OperationsRetry500,
+		OperationsRetry504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "operations.retry").annotate(OpenApi.Summary, "Retry an asynchronous operation").annotate(OpenApi.Description, "Retries a failed operation in place when its error is retryable. Retrying an organization deletion additionally requires `organization:delete`.")).annotate(OpenApi.Description, "Status of accepted asynchronous mutations") {};
+//#endregion
+//#region src/effect/operations.ts
+var operations_exports = /* @__PURE__ */ __exportAll({
+	get: () => get,
+	list: () => list,
+	retry: () => retry
+});
+const make = forGroup(OperationsGroup);
+const list = make("operationsList");
+const get = make("operationsGet");
+const retry = make("operationsRetry");
+//#endregion
+export { retry as i, list as n, operations_exports as r, get as t };
+
+//# sourceMappingURL=operations-CmB3FHwf.js.map

package/dist/organizations-A-plufWc.js

@@ -0,0 +1,252 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { At as OperationAccepted, J as IanaTimezone, Jt as UnauthorizedError, K as ForbiddenError, Lt as ResourceNotFoundError, Nt as PaymentRequiredError, Y as InternalError, en as ValidationError, et as JsonValue, l as BillingProviderError, m as ConflictError, q as GatewayTimeoutError, s as ApiKeySecurityMiddleware } from "./client-DOzUrdTE.js";
+import { n as forGroup } from "./operation-n_IYgNVK.js";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
+import * as Schema from "effect/Schema";
+//#region src/effect/generated/organizations.ts
+const Organization = /* @__PURE__ */ Schema.Struct({
+	id: Schema.String,
+	billingAccountId: Schema.String,
+	name: Schema.String,
+	slug: Schema.String,
+	countryCode: Schema.String,
+	timezone: Schema.String,
+	plan: Schema.String,
+	isActive: Schema.Boolean,
+	createdAt: Schema.String,
+	updatedAt: Schema.String,
+	metadata: Schema.Union([Schema.Record(Schema.String, JsonValue), Schema.Null]),
+	replyToDefault: Schema.Union([Schema.Array(Schema.String), Schema.Null]),
+	emailFooterEnabledDefault: Schema.Union([Schema.Boolean, Schema.Null]),
+	messagesUsed: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	messagesUsedThisMonth: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	emailUsed: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	emailUsedThisMonth: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	contactsUsed: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	conversationsUsed: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	teamMembersUsed: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+	messagesResetAt: Schema.Union([Schema.String, Schema.Null])
+}).annotate({ identifier: "Organization" });
+const OrganizationsCreateRequestJson = /* @__PURE__ */ Schema.Struct({ name: Schema.String });
+const OrganizationsCreate200 = Organization;
+const OrganizationsCreate401 = UnauthorizedError;
+const OrganizationsCreate402 = PaymentRequiredError;
+const OrganizationsCreate403 = ForbiddenError;
+const OrganizationsCreate422 = ValidationError;
+const OrganizationsCreate500 = InternalError;
+const OrganizationsCreate502 = BillingProviderError;
+const OrganizationsCreate504 = GatewayTimeoutError;
+const OrganizationsGet200 = Organization;
+const OrganizationsGet401 = UnauthorizedError;
+const OrganizationsGet403 = ForbiddenError;
+const OrganizationsGet404 = ResourceNotFoundError;
+const OrganizationsGet422 = ValidationError;
+const OrganizationsGet500 = InternalError;
+const OrganizationsGet504 = GatewayTimeoutError;
+const OrganizationsUpdateRequestJson = /* @__PURE__ */ Schema.Struct({
+	name: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	slug: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	countryCode: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	timezone: Schema.optionalKey(Schema.Union([IanaTimezone, Schema.Null])),
+	isActive: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Null])),
+	metadata: Schema.optionalKey(Schema.Union([Schema.Record(Schema.String, JsonValue), Schema.Null])),
+	replyToDefault: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Array(Schema.String), Schema.Null]), Schema.Null])),
+	emailFooterEnabledDefault: Schema.optionalKey(Schema.Union([Schema.Union([Schema.Boolean, Schema.Null]), Schema.Null]))
+});
+const OrganizationsUpdate200 = Organization;
+const OrganizationsUpdate401 = UnauthorizedError;
+const OrganizationsUpdate403 = ForbiddenError;
+const OrganizationsUpdate404 = ResourceNotFoundError;
+const OrganizationsUpdate422 = ValidationError;
+const OrganizationsUpdate500 = InternalError;
+const OrganizationsUpdate504 = GatewayTimeoutError;
+const OrganizationsGetProfile200 = /* @__PURE__ */ Schema.Struct({
+	id: Schema.String.annotate({ description: "Opaque identity for your organization membership" }),
+	name: Schema.String.annotate({ description: "Your display name" }),
+	nickname: Schema.String.annotate({ description: "Your display name and organization name" })
+});
+const OrganizationsGetProfile401 = UnauthorizedError;
+const OrganizationsGetProfile403 = ForbiddenError;
+const OrganizationsGetProfile422 = ValidationError;
+const OrganizationsGetProfile500 = InternalError;
+const OrganizationsGetProfile504 = GatewayTimeoutError;
+const OrganizationsDeleteHeaders = /* @__PURE__ */ Schema.Struct({ "idempotency-key": Schema.String.check(Schema.isMinLength(1).annotate({ expected: "a value with a length of at least 1" })).check(Schema.isMaxCodePoints(255).annotate({ expected: "a string with at most 255 code points" })).check(Schema.isMaxLength(255).annotate({ expected: "a value with a length of at most 255" })) });
+const OrganizationsDeleteRequestJson = /* @__PURE__ */ Schema.Struct({ confirmationName: Schema.String });
+const OrganizationsDelete202 = OperationAccepted;
+const OrganizationsDelete401 = UnauthorizedError;
+const OrganizationsDelete403 = ForbiddenError;
+const OrganizationsDelete409 = ConflictError;
+const OrganizationsDelete422 = ValidationError;
+const OrganizationsDelete500 = InternalError;
+const OrganizationsDelete504 = GatewayTimeoutError;
+const OrganizationsGetTrustTier200 = /* @__PURE__ */ Schema.Struct({
+	tier: Schema.Union([
+		Schema.Literal("screened"),
+		Schema.Literal("probation"),
+		Schema.Literal("established")
+	]),
+	changedAt: Schema.String,
+	sendingLimits: Schema.Struct({
+		sendsPerSecond: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		dailySends: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		probation: Schema.Union([Schema.Struct({
+			hourlyRecipients: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+			dailyRecipients: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+			domainShare: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+			domainShareFloor: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" }))
+		}), Schema.Null])
+	}),
+	graduation: Schema.Union([Schema.Struct({
+		firstSentAt: Schema.Union([Schema.String, Schema.Null]),
+		elapsedDays: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		sent: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		delivered: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		hardBounces: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		hardBounceRate: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })), Schema.Null]),
+		complaints: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		holds: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		requirements: Schema.Struct({
+			minimumDays: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+			delivered: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+			maximumHardBounceRate: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" }))
+		}),
+		blockers: Schema.Array(Schema.Union([
+			Schema.Literal("too_recent"),
+			Schema.Literal("too_few_delivered"),
+			Schema.Literal("held"),
+			Schema.Literal("complaints"),
+			Schema.Literal("bounce_rate")
+		]))
+	}), Schema.Null])
+});
+const OrganizationsGetTrustTier401 = UnauthorizedError;
+const OrganizationsGetTrustTier403 = ForbiddenError;
+const OrganizationsGetTrustTier404 = ResourceNotFoundError;
+const OrganizationsGetTrustTier422 = ValidationError;
+const OrganizationsGetTrustTier500 = InternalError;
+const OrganizationsGetTrustTier502 = BillingProviderError;
+const OrganizationsGetTrustTier504 = GatewayTimeoutError;
+const OrganizationsGetUsageQuery = /* @__PURE__ */ Schema.Struct({
+	after: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null])),
+	before: Schema.optionalKey(Schema.Union([Schema.String, Schema.Null]))
+});
+const OrganizationsGetUsage200 = /* @__PURE__ */ Schema.Struct({
+	usage: Schema.Struct({
+		periodStart: Schema.String,
+		periodEnd: Schema.String,
+		emailCount: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })),
+		totalMessages: Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" }))
+	}),
+	billing: Schema.Struct({
+		currency: Schema.String,
+		planName: Schema.Union([Schema.String, Schema.Null]),
+		includedEmails: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })), Schema.Null]),
+		usedEmails: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })), Schema.Null]),
+		overageEmails: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })), Schema.Null]),
+		overageCost: Schema.Union([Schema.Finite.check(Schema.isFinite().annotate({ expected: "a finite number" })), Schema.Null])
+	})
+});
+const OrganizationsGetUsage401 = UnauthorizedError;
+const OrganizationsGetUsage403 = ForbiddenError;
+const OrganizationsGetUsage422 = ValidationError;
+const OrganizationsGetUsage500 = InternalError;
+const OrganizationsGetUsage504 = GatewayTimeoutError;
+var OrganizationsGroup = class extends HttpApiGroup.make("Organizations").add(HttpApiEndpoint.post("organizationsCreate", "/v1/organizations", {
+	payload: OrganizationsCreateRequestJson,
+	success: OrganizationsCreate200,
+	error: [
+		OrganizationsCreate401.pipe(HttpApiSchema.status(401)),
+		OrganizationsCreate402.pipe(HttpApiSchema.status(402)),
+		OrganizationsCreate403.pipe(HttpApiSchema.status(403)),
+		OrganizationsCreate422.pipe(HttpApiSchema.status(422)),
+		OrganizationsCreate500,
+		OrganizationsCreate502.pipe(HttpApiSchema.status(502)),
+		OrganizationsCreate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.create").annotate(OpenApi.Summary, "Create an organization").annotate(OpenApi.Description, "Creates a new organization under the current billing account and returns it."), HttpApiEndpoint.get("organizationsGet", "/v1/organizations/current", {
+	success: OrganizationsGet200,
+	error: [
+		OrganizationsGet401.pipe(HttpApiSchema.status(401)),
+		OrganizationsGet403.pipe(HttpApiSchema.status(403)),
+		OrganizationsGet404.pipe(HttpApiSchema.status(404)),
+		OrganizationsGet422.pipe(HttpApiSchema.status(422)),
+		OrganizationsGet500,
+		OrganizationsGet504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.get").annotate(OpenApi.Summary, "Get the current organization").annotate(OpenApi.Description, "Returns the organization for the current billing account."), HttpApiEndpoint.patch("organizationsUpdate", "/v1/organizations/current", {
+	payload: OrganizationsUpdateRequestJson,
+	success: OrganizationsUpdate200,
+	error: [
+		OrganizationsUpdate401.pipe(HttpApiSchema.status(401)),
+		OrganizationsUpdate403.pipe(HttpApiSchema.status(403)),
+		OrganizationsUpdate404.pipe(HttpApiSchema.status(404)),
+		OrganizationsUpdate422.pipe(HttpApiSchema.status(422)),
+		OrganizationsUpdate500,
+		OrganizationsUpdate504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.update").annotate(OpenApi.Summary, "Update the current organization").annotate(OpenApi.Description, "Updates the current organization's profile, regional defaults, and reply-to default and returns the saved organization. `metadata` is merged into the stored value; every other field is replaced."), HttpApiEndpoint.get("organizationsGetProfile", "/v1/organizations/current/profile", {
+	success: OrganizationsGetProfile200,
+	error: [
+		OrganizationsGetProfile401.pipe(HttpApiSchema.status(401)),
+		OrganizationsGetProfile403.pipe(HttpApiSchema.status(403)),
+		OrganizationsGetProfile422.pipe(HttpApiSchema.status(422)),
+		OrganizationsGetProfile500,
+		OrganizationsGetProfile504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.getProfile").annotate(OpenApi.Summary, "Get the current account profile").annotate(OpenApi.Description, "Returns your identity in the organization authorized by your credential. The ID remains stable across reconnects and display-name changes. Removing and re-adding your membership creates a new ID."), HttpApiEndpoint.post("organizationsDelete", "/v1/organizations/deletion-operations", {
+	headers: OrganizationsDeleteHeaders,
+	payload: OrganizationsDeleteRequestJson,
+	success: OrganizationsDelete202.pipe(HttpApiSchema.status(202)),
+	error: [
+		OrganizationsDelete401.pipe(HttpApiSchema.status(401)),
+		OrganizationsDelete403.pipe(HttpApiSchema.status(403)),
+		OrganizationsDelete409.pipe(HttpApiSchema.status(409)),
+		OrganizationsDelete422.pipe(HttpApiSchema.status(422)),
+		OrganizationsDelete500,
+		OrganizationsDelete504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.delete").annotate(OpenApi.Summary, "Delete the current organization").annotate(OpenApi.Description, "Starts an owner-authorized organization deletion operation, confirming the organization name in the request. Repeating the same request with the same Idempotency-Key returns the existing organization-scoped operation."), HttpApiEndpoint.get("organizationsGetTrustTier", "/v1/organizations/trust-tier", {
+	success: OrganizationsGetTrustTier200,
+	error: [
+		OrganizationsGetTrustTier401.pipe(HttpApiSchema.status(401)),
+		OrganizationsGetTrustTier403.pipe(HttpApiSchema.status(403)),
+		OrganizationsGetTrustTier404.pipe(HttpApiSchema.status(404)),
+		OrganizationsGetTrustTier422.pipe(HttpApiSchema.status(422)),
+		OrganizationsGetTrustTier500,
+		OrganizationsGetTrustTier502.pipe(HttpApiSchema.status(502)),
+		OrganizationsGetTrustTier504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.getTrustTier").annotate(OpenApi.Summary, "Get organization trust tier and sending limits").annotate(OpenApi.Description, "Returns the current trust tier, plan and probation sending limits, and measured probation graduation progress. Limits are additional to billing allowance, domain readiness, and enforcement. Graduation is evaluated on delivery events."), HttpApiEndpoint.get("organizationsGetUsage", "/v1/organizations/usage", {
+	query: OrganizationsGetUsageQuery,
+	success: OrganizationsGetUsage200,
+	error: [
+		OrganizationsGetUsage401.pipe(HttpApiSchema.status(401)),
+		OrganizationsGetUsage403.pipe(HttpApiSchema.status(403)),
+		OrganizationsGetUsage422.pipe(HttpApiSchema.status(422)),
+		OrganizationsGetUsage500,
+		OrganizationsGetUsage504.pipe(HttpApiSchema.status(504))
+	]
+}).middleware(ApiKeySecurityMiddleware).annotate(OpenApi.Identifier, "organizations.getUsage").annotate(OpenApi.Summary, "Get organization usage").annotate(OpenApi.Description, "Returns usage statistics for the current organization between `after` and `before`, which default to the current calendar month so far. `usage.periodStart` and `usage.periodEnd` echo the window counted.")).annotate(OpenApi.Description, "Organization management and usage statistics") {};
+//#endregion
+//#region src/effect/organizations.ts
+var organizations_exports = /* @__PURE__ */ __exportAll({
+	create: () => create,
+	delete: () => deleteOrganization,
+	get: () => get,
+	getProfile: () => getProfile,
+	getTrustTier: () => getTrustTier,
+	getUsage: () => getUsage,
+	update: () => update
+});
+const make = forGroup(OrganizationsGroup);
+const create = make("organizationsCreate");
+const get = make("organizationsGet");
+const getProfile = make("organizationsGetProfile");
+const getTrustTier = make("organizationsGetTrustTier");
+const update = make("organizationsUpdate");
+const getUsage = make("organizationsGetUsage");
+const deleteOrganization = make("organizationsDelete");
+//#endregion
+export { getTrustTier as a, update as c, getProfile as i, deleteOrganization as n, getUsage as o, get as r, organizations_exports as s, create as t };
+
+//# sourceMappingURL=organizations-A-plufWc.js.map

package/dist/promises/errors.gen.d.ts

@@ -1,4 +1,4 @@
-export type SamvaApiErrorTag = "AnalyticsQueryError" | "BillingProviderError" | "BrandAddressRequiredError" | "CampaignFooterRequiredError" | "ConflictError" | "DeliveryUnavailableError" | "EmailChannelError" | "ExternalServiceError" | "FlagDisabledError" | "ForbiddenError" | "GatewayTimeoutError" | "InternalError" | "MailboxSendConflictError" | "MailboxSendRefusedError" | "OnboardingReviewRequiredError" | "PaymentRequiredError" | "RateLimitedError" | "ResourceNotFoundError" | "SenderNotReadyError" | "UnauthorizedError" | "ValidationError";
+export type SamvaApiErrorTag = "AnalyticsQueryError" | "BillingProviderError" | "BrandAddressRequiredError" | "CampaignFooterRequiredError" | "ConflictError" | "DeliveryUnavailableError" | "EmailChannelError" | "ExternalServiceError" | "FlagDisabledError" | "ForbiddenError" | "GatewayTimeoutError" | "InternalError" | "MailboxChannelUnsupportedError" | "MailboxSendConflictError" | "MailboxSendRefusedError" | "OnboardingReviewRequiredError" | "PaymentRequiredError" | "RateLimitedError" | "ResourceNotFoundError" | "SenderNotReadyError" | "UnauthorizedError" | "ValidationError";
 export interface SamvaApiErrorContext {
     readonly request?: Request | undefined;
     readonly response?: Response | undefined;
@@ -132,6 +132,16 @@ export declare class InternalError extends SamvaApiError<"InternalError"> {
     readonly _tag: "InternalError";
     constructor(payload: Omit<InternalErrorPayload, "_tag">, context?: SamvaApiErrorContext);
 }
+type MailboxChannelUnsupportedErrorPayload = {
+    readonly _tag: "MailboxChannelUnsupportedError";
+    readonly channel: string;
+    readonly message: string;
+};
+export declare class MailboxChannelUnsupportedError extends SamvaApiError<"MailboxChannelUnsupportedError"> {
+    readonly _tag: "MailboxChannelUnsupportedError";
+    readonly "channel": string;
+    constructor(payload: Omit<MailboxChannelUnsupportedErrorPayload, "_tag">, context?: SamvaApiErrorContext);
+}
 type MailboxSendConflictErrorPayload = {
     readonly _tag: "MailboxSendConflictError";
     readonly id: string;
@@ -240,7 +250,7 @@ export declare class ValidationError extends SamvaApiError<"ValidationError"> {
     readonly "fields"?: Record<string, Array<string>> | null;
     constructor(payload: Omit<ValidationErrorPayload, "_tag">, context?: SamvaApiErrorContext);
 }
-export type AnySamvaApiError = AnalyticsQueryError | BillingProviderError | BrandAddressRequiredError | CampaignFooterRequiredError | ConflictError | DeliveryUnavailableError | EmailChannelError | ExternalServiceError | FlagDisabledError | ForbiddenError | GatewayTimeoutError | InternalError | MailboxSendConflictError | MailboxSendRefusedError | OnboardingReviewRequiredError | PaymentRequiredError | RateLimitedError | ResourceNotFoundError | SenderNotReadyError | UnauthorizedError | ValidationError;
+export type AnySamvaApiError = AnalyticsQueryError | BillingProviderError | BrandAddressRequiredError | CampaignFooterRequiredError | ConflictError | DeliveryUnavailableError | EmailChannelError | ExternalServiceError | FlagDisabledError | ForbiddenError | GatewayTimeoutError | InternalError | MailboxChannelUnsupportedError | MailboxSendConflictError | MailboxSendRefusedError | OnboardingReviewRequiredError | PaymentRequiredError | RateLimitedError | ResourceNotFoundError | SenderNotReadyError | UnauthorizedError | ValidationError;
 /** Convert a decoded error payload into its generated JavaScript error class. */
 export declare function fromApiError(error: unknown, context?: SamvaApiErrorContext): AnySamvaApiError | SamvaTransportError;
 export {};

package/dist/promises/index.d.ts

@@ -27,7 +27,7 @@
  * ```
  */
 import { type Client, type Config } from "../client/client";
-import { Analytics as analytics, ApiKeys as apiKeys, Attachments as attachments, Brands as brands, Campaigns as campaigns, ContactGroups as contactGroups, Contacts as contacts, Conversations as conversations, CustomFields as customFields, Email as email, ExtensionInstallations as extensionInstallations, Extensions as extensions, Feedback as feedback, Mailboxes as mailboxes, Media as media, Messages as messages, Namespaces as namespaces, Operations as operations, Organizations as organizations, ScheduledMessages as scheduledMessages, Subscriptions as subscriptions, Templates as templates, Unsubscribe as unsubscribeGroups, Webhooks as webhooks } from "../client/sdk.gen";
+import { Analytics as analytics, ApiKeys as apiKeys, Attachments as attachments, Brands as brands, Campaigns as campaigns, ContactGroups as contactGroups, ContactEvents as contactEvents, Contacts as contacts, Conversations as conversations, CustomFields as customFields, Email as email, ExtensionInstallations as extensionInstallations, Extensions as extensions, Events as events, Feedback as feedback, Journeys as journeys, Mailboxes as mailboxes, Media as media, Messages as messages, Namespaces as namespaces, Operations as operations, Organizations as organizations, ScheduledMessages as scheduledMessages, Subscriptions as subscriptions, Templates as templates, Unsubscribe as unsubscribeGroups, Webhooks as webhooks, Whoami as whoami } from "../client/sdk.gen";
 import type { MessagesSendData } from "../client/types.gen";
 import { MailboxEventStream, type MailboxEventStreamOptions } from "../mailbox-events";
 export * from "./errors.gen";
@@ -126,7 +126,8 @@ export interface SamvaRawClient {
     readonly email: typeof email;
     readonly media: typeof media;
     readonly templates: PromiseTemplatesTransport;
-    readonly contacts: typeof contacts;
+    readonly contacts: typeof contacts & typeof contactEvents;
+    readonly events: typeof events;
     readonly conversations: typeof conversations;
     readonly webhooks: typeof webhooks;
     readonly operations: typeof operations;
@@ -139,6 +140,8 @@ export interface SamvaRawClient {
     readonly unsubscribeGroups: typeof unsubscribeGroups;
     readonly analytics: typeof analytics;
     readonly feedback: typeof feedback;
+    readonly whoami: typeof whoami;
+    readonly journeys: typeof journeys;
     readonly mailboxes: typeof mailboxes;
     readonly namespaces: typeof namespaces;
     readonly extensions: typeof extensions;
@@ -162,7 +165,8 @@ export interface SamvaClient {
     readonly email: DirectService<PromiseEmailTransport>;
     readonly media: DirectService<typeof media>;
     readonly templates: DirectService<PromiseTemplatesTransport>;
-    readonly contacts: DirectService<typeof contacts>;
+    readonly contacts: DirectService<typeof contacts & typeof contactEvents>;
+    readonly events: DirectService<typeof events>;
     readonly conversations: DirectService<typeof conversations>;
     readonly webhooks: DirectService<typeof webhooks>;
     readonly operations: DirectService<typeof operations>;
@@ -175,6 +179,8 @@ export interface SamvaClient {
     readonly unsubscribeGroups: DirectService<typeof unsubscribeGroups>;
     readonly analytics: DirectService<typeof analytics>;
     readonly feedback: DirectService<typeof feedback>;
+    readonly whoami: DirectService<typeof whoami>;
+    readonly journeys: DirectService<typeof journeys>;
     readonly mailboxes: PromiseMailboxesService;
     readonly namespaces: DirectService<typeof namespaces>;
     readonly extensions: DirectService<typeof extensions>;

package/dist/promises/index.js

@@ -1,4 +1,4 @@
-import { t as MediaUploadError } from "../inline-attachments-UxLeyytJ.js";
-import { C as UnauthorizedError, S as SenderNotReadyError, T as fromApiError, _ as PaymentRequiredError, a as CampaignFooterRequiredError, b as SamvaApiError, c as EmailChannelError, d as ForbiddenError, f as GatewayTimeoutError, g as OnboardingReviewRequiredError, h as MailboxSendRefusedError, i as BrandAddressRequiredError, l as ExternalServiceError, m as MailboxSendConflictError, n as AnalyticsQueryError, o as ConflictError, p as InternalError, r as BillingProviderError, s as DeliveryUnavailableError, t as createClient, u as FlagDisabledError, v as RateLimitedError, w as ValidationError, x as SamvaTransportError, y as ResourceNotFoundError } from "../promises-Cd6Jamqk.js";
+import { t as MediaUploadError } from "../inline-attachments-Bi1hDltp.js";
+import { C as SenderNotReadyError, E as fromApiError, S as SamvaTransportError, T as ValidationError, _ as OnboardingReviewRequiredError, a as CampaignFooterRequiredError, b as ResourceNotFoundError, c as EmailChannelError, d as ForbiddenError, f as GatewayTimeoutError, g as MailboxSendRefusedError, h as MailboxSendConflictError, i as BrandAddressRequiredError, l as ExternalServiceError, m as MailboxChannelUnsupportedError, n as AnalyticsQueryError, o as ConflictError, p as InternalError, r as BillingProviderError, s as DeliveryUnavailableError, t as createClient, u as FlagDisabledError, v as PaymentRequiredError, w as UnauthorizedError, x as SamvaApiError, y as RateLimitedError } from "../promises---Kbh-7z.js";
 import { n as MailboxEventStreamError, t as MailboxEventStream } from "../mailbox-events-VKR4f3qq.js";
-export { AnalyticsQueryError, BillingProviderError, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, DeliveryUnavailableError, EmailChannelError, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, MailboxEventStream, MailboxEventStreamError, MailboxSendConflictError, MailboxSendRefusedError, MediaUploadError, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SamvaApiError, SamvaTransportError, SenderNotReadyError, UnauthorizedError, ValidationError, createClient, fromApiError };
+export { AnalyticsQueryError, BillingProviderError, BrandAddressRequiredError, CampaignFooterRequiredError, ConflictError, DeliveryUnavailableError, EmailChannelError, ExternalServiceError, FlagDisabledError, ForbiddenError, GatewayTimeoutError, InternalError, MailboxChannelUnsupportedError, MailboxEventStream, MailboxEventStreamError, MailboxSendConflictError, MailboxSendRefusedError, MediaUploadError, OnboardingReviewRequiredError, PaymentRequiredError, RateLimitedError, ResourceNotFoundError, SamvaApiError, SamvaTransportError, SenderNotReadyError, UnauthorizedError, ValidationError, createClient, fromApiError };