@maesn/typescript-sdk 0.2.1 → 0.2.2

package/src/models/operations/create-webhook-end-user.ts

@@ -3,14 +3,50 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
 export type CreateWebhookEndUserRequest = {
+  /**
+   * Environment name (required for multi-environment systems such as Business Central)
+   */
   environmentName?: string | undefined;
+  /**
+   * ID of the company (required for multi-company target systems)
+   */
   companyId?: string | undefined;
   body: models.CreateAccountingWebhookRequestDto;
 };
 
+export type CreateWebhookEndUserPagination = {
+  total: number;
+  perPage: number;
+  currentPage: number;
+  totalPages: number;
+};
+
+export type CreateWebhookEndUserMeta = {
+  warnings?: Array<string> | null | undefined;
+  pagination?: CreateWebhookEndUserPagination | null | undefined;
+};
+
+export type CreateWebhookEndUserErrors = {};
+
+export type CreateWebhookEndUserRawData = {};
+
+/**
+ * Webhook created successfully
+ */
+export type CreateWebhookEndUserResponse = {
+  meta?: CreateWebhookEndUserMeta | null | undefined;
+  data: models.WebhookResponseDto;
+  errors: CreateWebhookEndUserErrors | null;
+  rawData: CreateWebhookEndUserRawData | null;
+};
+
 /** @internal */
 export type CreateWebhookEndUserRequest$Outbound = {
   environmentName?: string | undefined;
@@ -37,3 +73,104 @@ export function createWebhookEndUserRequestToJSON(
     ),
   );
 }
+
+/** @internal */
+export const CreateWebhookEndUserPagination$inboundSchema: z.ZodMiniType<
+  CreateWebhookEndUserPagination,
+  unknown
+> = z.object({
+  total: types.number(),
+  perPage: types.number(),
+  currentPage: types.number(),
+  totalPages: types.number(),
+});
+
+export function createWebhookEndUserPaginationFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookEndUserPagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookEndUserPagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookEndUserPagination' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookEndUserMeta$inboundSchema: z.ZodMiniType<
+  CreateWebhookEndUserMeta,
+  unknown
+> = z.object({
+  warnings: z.optional(z.nullable(z.array(types.string()))),
+  pagination: z.optional(
+    z.nullable(z.lazy(() => CreateWebhookEndUserPagination$inboundSchema)),
+  ),
+});
+
+export function createWebhookEndUserMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookEndUserMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookEndUserMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookEndUserMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookEndUserErrors$inboundSchema: z.ZodMiniType<
+  CreateWebhookEndUserErrors,
+  unknown
+> = z.object({});
+
+export function createWebhookEndUserErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookEndUserErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookEndUserErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookEndUserErrors' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookEndUserRawData$inboundSchema: z.ZodMiniType<
+  CreateWebhookEndUserRawData,
+  unknown
+> = z.object({});
+
+export function createWebhookEndUserRawDataFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookEndUserRawData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookEndUserRawData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookEndUserRawData' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookEndUserResponse$inboundSchema: z.ZodMiniType<
+  CreateWebhookEndUserResponse,
+  unknown
+> = z.object({
+  meta: z.optional(
+    z.nullable(z.lazy(() => CreateWebhookEndUserMeta$inboundSchema)),
+  ),
+  data: models.WebhookResponseDto$inboundSchema,
+  errors: types.nullable(
+    z.lazy(() => CreateWebhookEndUserErrors$inboundSchema),
+  ),
+  rawData: types.nullable(
+    z.lazy(() => CreateWebhookEndUserRawData$inboundSchema),
+  ),
+});
+
+export function createWebhookEndUserResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookEndUserResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookEndUserResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookEndUserResponse' from JSON`,
+  );
+}

package/src/models/operations/create-webhook.ts

@@ -3,14 +3,50 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
 
 export type CreateWebhookRequest = {
+  /**
+   * Environment name (required for multi-environment systems such as Business Central)
+   */
   environmentName?: string | undefined;
+  /**
+   * ID of the company (required for multi-company target systems)
+   */
   companyId?: string | undefined;
   body: models.CreateAccountingWebhookRequestDto;
 };
 
+export type CreateWebhookPagination = {
+  total: number;
+  perPage: number;
+  currentPage: number;
+  totalPages: number;
+};
+
+export type CreateWebhookMeta = {
+  warnings?: Array<string> | null | undefined;
+  pagination?: CreateWebhookPagination | null | undefined;
+};
+
+export type CreateWebhookErrors = {};
+
+export type CreateWebhookRawData = {};
+
+/**
+ * Webhook created successfully
+ */
+export type CreateWebhookResponse = {
+  meta?: CreateWebhookMeta | null | undefined;
+  data: models.WebhookResponseDto;
+  errors: CreateWebhookErrors | null;
+  rawData: CreateWebhookRawData | null;
+};
+
 /** @internal */
 export type CreateWebhookRequest$Outbound = {
   environmentName?: string | undefined;
@@ -35,3 +71,98 @@ export function createWebhookRequestToJSON(
     CreateWebhookRequest$outboundSchema.parse(createWebhookRequest),
   );
 }
+
+/** @internal */
+export const CreateWebhookPagination$inboundSchema: z.ZodMiniType<
+  CreateWebhookPagination,
+  unknown
+> = z.object({
+  total: types.number(),
+  perPage: types.number(),
+  currentPage: types.number(),
+  totalPages: types.number(),
+});
+
+export function createWebhookPaginationFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookPagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookPagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookPagination' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookMeta$inboundSchema: z.ZodMiniType<
+  CreateWebhookMeta,
+  unknown
+> = z.object({
+  warnings: z.optional(z.nullable(z.array(types.string()))),
+  pagination: z.optional(
+    z.nullable(z.lazy(() => CreateWebhookPagination$inboundSchema)),
+  ),
+});
+
+export function createWebhookMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookErrors$inboundSchema: z.ZodMiniType<
+  CreateWebhookErrors,
+  unknown
+> = z.object({});
+
+export function createWebhookErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookErrors' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookRawData$inboundSchema: z.ZodMiniType<
+  CreateWebhookRawData,
+  unknown
+> = z.object({});
+
+export function createWebhookRawDataFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookRawData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookRawData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookRawData' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateWebhookResponse$inboundSchema: z.ZodMiniType<
+  CreateWebhookResponse,
+  unknown
+> = z.object({
+  meta: z.optional(z.nullable(z.lazy(() => CreateWebhookMeta$inboundSchema))),
+  data: models.WebhookResponseDto$inboundSchema,
+  errors: types.nullable(z.lazy(() => CreateWebhookErrors$inboundSchema)),
+  rawData: types.nullable(z.lazy(() => CreateWebhookRawData$inboundSchema)),
+});
+
+export function createWebhookResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateWebhookResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateWebhookResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateWebhookResponse' from JSON`,
+  );
+}

package/src/models/operations/delete-bill.ts

@@ -3,13 +3,49 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type DeleteBillRequest = {
   billId: string;
+  /**
+   * Environment name (required for multi-environment systems such as Business Central)
+   */
   environmentName?: string | undefined;
+  /**
+   * ID of the company (required for multi-company target systems)
+   */
   companyId?: string | undefined;
 };
 
+export type DeleteBillPagination = {
+  total: number;
+  perPage: number;
+  currentPage: number;
+  totalPages: number;
+};
+
+export type DeleteBillMeta = {
+  warnings?: Array<string> | null | undefined;
+  pagination?: DeleteBillPagination | null | undefined;
+};
+
+export type DeleteBillErrors = {};
+
+export type DeleteBillRawData = {};
+
+/**
+ * Operation completed successfully
+ */
+export type DeleteBillResponse = {
+  meta?: DeleteBillMeta | null | undefined;
+  data: string;
+  errors: DeleteBillErrors | null;
+  rawData: DeleteBillRawData | null;
+};
+
 /** @internal */
 export type DeleteBillRequest$Outbound = {
   billId: string;
@@ -34,3 +70,98 @@ export function deleteBillRequestToJSON(
     DeleteBillRequest$outboundSchema.parse(deleteBillRequest),
   );
 }
+
+/** @internal */
+export const DeleteBillPagination$inboundSchema: z.ZodMiniType<
+  DeleteBillPagination,
+  unknown
+> = z.object({
+  total: types.number(),
+  perPage: types.number(),
+  currentPage: types.number(),
+  totalPages: types.number(),
+});
+
+export function deleteBillPaginationFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteBillPagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteBillPagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteBillPagination' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteBillMeta$inboundSchema: z.ZodMiniType<
+  DeleteBillMeta,
+  unknown
+> = z.object({
+  warnings: z.optional(z.nullable(z.array(types.string()))),
+  pagination: z.optional(
+    z.nullable(z.lazy(() => DeleteBillPagination$inboundSchema)),
+  ),
+});
+
+export function deleteBillMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteBillMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteBillMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteBillMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteBillErrors$inboundSchema: z.ZodMiniType<
+  DeleteBillErrors,
+  unknown
+> = z.object({});
+
+export function deleteBillErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteBillErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteBillErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteBillErrors' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteBillRawData$inboundSchema: z.ZodMiniType<
+  DeleteBillRawData,
+  unknown
+> = z.object({});
+
+export function deleteBillRawDataFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteBillRawData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteBillRawData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteBillRawData' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeleteBillResponse$inboundSchema: z.ZodMiniType<
+  DeleteBillResponse,
+  unknown
+> = z.object({
+  meta: z.optional(z.nullable(z.lazy(() => DeleteBillMeta$inboundSchema))),
+  data: types.string(),
+  errors: types.nullable(z.lazy(() => DeleteBillErrors$inboundSchema)),
+  rawData: types.nullable(z.lazy(() => DeleteBillRawData$inboundSchema)),
+});
+
+export function deleteBillResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteBillResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteBillResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteBillResponse' from JSON`,
+  );
+}

package/src/models/operations/delete-end-user.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+/**
+ * Operation completed successfully
+ */
+export type DeleteEndUserResponse = {
+  message?: string | undefined;
+};
+
+/** @internal */
+export const DeleteEndUserResponse$inboundSchema: z.ZodMiniType<
+  DeleteEndUserResponse,
+  unknown
+> = z.object({
+  message: types.optional(types.string()),
+});
+
+export function deleteEndUserResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeleteEndUserResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeleteEndUserResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeleteEndUserResponse' from JSON`,
+  );
+}

package/src/models/operations/delete-event-subscriptions.ts

@@ -6,6 +6,9 @@ import * as z from "zod/v4-mini";
 
 export type DeleteEventSubscriptionsRequest = {
   eventSubscriptionId: string;
+  /**
+   * ID of the company (required for multi-company target systems)
+   */
   companyId?: string | undefined;
 };
 

package/src/models/operations/delete-payment.ts

@@ -3,12 +3,45 @@
  */
 
 import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
 
 export type DeletePaymentRequest = {
   paymentId: string;
+  /**
+   * ID of the company (required for multi-company target systems)
+   */
   companyId?: string | undefined;
 };
 
+export type DeletePaymentPagination = {
+  total: number;
+  perPage: number;
+  currentPage: number;
+  totalPages: number;
+};
+
+export type DeletePaymentMeta = {
+  warnings?: Array<string> | null | undefined;
+  pagination?: DeletePaymentPagination | null | undefined;
+};
+
+export type DeletePaymentErrors = {};
+
+export type DeletePaymentRawData = {};
+
+/**
+ * Operation completed successfully
+ */
+export type DeletePaymentResponse = {
+  meta?: DeletePaymentMeta | null | undefined;
+  data: string;
+  errors: DeletePaymentErrors | null;
+  rawData: DeletePaymentRawData | null;
+};
+
 /** @internal */
 export type DeletePaymentRequest$Outbound = {
   paymentId: string;
@@ -31,3 +64,98 @@ export function deletePaymentRequestToJSON(
     DeletePaymentRequest$outboundSchema.parse(deletePaymentRequest),
   );
 }
+
+/** @internal */
+export const DeletePaymentPagination$inboundSchema: z.ZodMiniType<
+  DeletePaymentPagination,
+  unknown
+> = z.object({
+  total: types.number(),
+  perPage: types.number(),
+  currentPage: types.number(),
+  totalPages: types.number(),
+});
+
+export function deletePaymentPaginationFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePaymentPagination, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePaymentPagination$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePaymentPagination' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeletePaymentMeta$inboundSchema: z.ZodMiniType<
+  DeletePaymentMeta,
+  unknown
+> = z.object({
+  warnings: z.optional(z.nullable(z.array(types.string()))),
+  pagination: z.optional(
+    z.nullable(z.lazy(() => DeletePaymentPagination$inboundSchema)),
+  ),
+});
+
+export function deletePaymentMetaFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePaymentMeta, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePaymentMeta$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePaymentMeta' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeletePaymentErrors$inboundSchema: z.ZodMiniType<
+  DeletePaymentErrors,
+  unknown
+> = z.object({});
+
+export function deletePaymentErrorsFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePaymentErrors, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePaymentErrors$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePaymentErrors' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeletePaymentRawData$inboundSchema: z.ZodMiniType<
+  DeletePaymentRawData,
+  unknown
+> = z.object({});
+
+export function deletePaymentRawDataFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePaymentRawData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePaymentRawData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePaymentRawData' from JSON`,
+  );
+}
+
+/** @internal */
+export const DeletePaymentResponse$inboundSchema: z.ZodMiniType<
+  DeletePaymentResponse,
+  unknown
+> = z.object({
+  meta: z.optional(z.nullable(z.lazy(() => DeletePaymentMeta$inboundSchema))),
+  data: types.string(),
+  errors: types.nullable(z.lazy(() => DeletePaymentErrors$inboundSchema)),
+  rawData: types.nullable(z.lazy(() => DeletePaymentRawData$inboundSchema)),
+});
+
+export function deletePaymentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DeletePaymentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DeletePaymentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DeletePaymentResponse' from JSON`,
+  );
+}