@powerhousedao/renown-package 0.0.2 → 0.0.4

package/dist/document-models/renown-credential/gen/document-model.js

@@ -17,35 +17,121 @@ export const documentModel = {
                     name: "manager",
                     operations: [
                         {
-                            description: "",
-                            errors: [],
+                            description: "Initialize a W3C Verifiable Credential with required fields",
+                            errors: [
+                                {
+                                    code: "MISSING_CONTEXT",
+                                    description: "The @context field is required for W3C VC compliance",
+                                    id: "missing-context-error",
+                                    name: "MissingContextError",
+                                    template: "",
+                                },
+                                {
+                                    code: "MISSING_TYPE",
+                                    description: "The type field is required and must include VerifiableCredential",
+                                    id: "missing-type-error",
+                                    name: "MissingTypeError",
+                                    template: "",
+                                },
+                                {
+                                    code: "INVALID_CLAIMS",
+                                    description: "The subject claims must be valid JSON",
+                                    id: "invalid-claims-error",
+                                    name: "InvalidClaimsError",
+                                    template: "",
+                                },
+                            ],
                             examples: [],
                             id: "366dfd44-377f-42d7-949d-a8d82b6a909d",
                             name: "INIT",
-                            reducer: "",
-                            schema: 'input InitInput {\n  "Add your inputs here"\n  jwt: String!\n  issuer: String\n  subject: String\n  audience: String\n  payload: String\n}',
+                            reducer: '// Validate context\nconst context = action.input.context && action.input.context.length > 0 \n  ? action.input.context \n  : ["https://www.w3.org/2018/credentials/v1"];\n\nif (!context.includes("https://www.w3.org/2018/credentials/v1")) {\n  throw new MissingContextError("Context must include https://www.w3.org/2018/credentials/v1");\n}\n\n// Validate type\nconst type = action.input.type && action.input.type.length > 0\n  ? action.input.type\n  : ["VerifiableCredential"];\n\nif (!type.includes("VerifiableCredential")) {\n  throw new MissingTypeError("Type must include VerifiableCredential");\n}\n\n// Validate credentialSubject is valid JSON\ntry {\n  JSON.parse(action.input.credentialSubject);\n} catch (e) {\n  throw new InvalidClaimsError("Credential subject must be valid JSON");\n}\n\nstate.context = context;\nstate.id = action.input.id || null;\nstate.type = type;\nstate.issuer = action.input.issuer;\nstate.issuanceDate = action.input.issuanceDate;\nstate.credentialSubject = action.input.credentialSubject;\nstate.expirationDate = action.input.expirationDate || null;\nstate.credentialStatus = null;\nstate.jwt = null;\nstate.revoked = false;\nstate.revokedAt = null;\nstate.revocationReason = null;',
+                            schema: "input InitInput {\n  context: [String!]\n  id: String\n  type: [String!]\n  issuer: String!\n  issuanceDate: DateTime!\n  credentialSubject: String!\n  expirationDate: DateTime\n}",
                             scope: "global",
                             template: "",
                         },
                         {
-                            description: "",
-                            errors: [],
+                            description: "Marks the credential as revoked",
+                            errors: [
+                                {
+                                    code: "ALREADY_REVOKED",
+                                    description: "The credential is already revoked",
+                                    id: "already-revoked-error",
+                                    name: "AlreadyRevokedError",
+                                    template: "",
+                                },
+                            ],
                             examples: [],
                             id: "8d8ed639-f7c4-43a5-8644-85729bd5b7dc",
                             name: "REVOKE",
-                            reducer: "",
-                            schema: "input RevokeInput {\n  jwt: String\n}",
+                            reducer: 'if (state.revoked) {\n  throw new AlreadyRevokedError("Credential is already revoked");\n}\n\nstate.revoked = true;\nstate.revokedAt = action.input.revokedAt;\nstate.revocationReason = action.input.reason || null;',
+                            schema: "input RevokeInput {\n  revokedAt: DateTime!\n  reason: String\n}",
                             scope: "global",
                             template: "",
                         },
+                        {
+                            description: "Updates the credential subject claims",
+                            errors: [
+                                {
+                                    code: "INVALID_CLAIMS",
+                                    description: "The subject claims must be valid JSON",
+                                    id: "invalid-claims-error-2",
+                                    name: "InvalidClaimsError",
+                                    template: "",
+                                },
+                                {
+                                    code: "CREDENTIAL_REVOKED",
+                                    description: "Cannot update a revoked credential",
+                                    id: "credential-revoked-error",
+                                    name: "CredentialRevokedError",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            id: "update-credential-subject-op",
+                            name: "UPDATE_CREDENTIAL_SUBJECT",
+                            reducer: 'if (state.revoked) {\n  throw new CredentialRevokedError("Cannot update a revoked credential");\n}\n\n// Validate credentialSubject is valid JSON\ntry {\n  JSON.parse(action.input.credentialSubject);\n} catch (e) {\n  throw new InvalidClaimsError("Credential subject must be valid JSON");\n}\n\nstate.credentialSubject = action.input.credentialSubject;\n\n// Clear JWT as credential content has changed\nstate.jwt = null;',
+                            schema: "input UpdateCredentialSubjectInput {\n  credentialSubject: String!\n}",
+                            scope: "global",
+                            template: "Updates the credential subject claims",
+                        },
+                        {
+                            description: "Sets the signed JWT representation of the credential",
+                            errors: [],
+                            examples: [],
+                            id: "set-jwt-op",
+                            name: "SET_JWT",
+                            reducer: "state.jwt = action.input.jwt;",
+                            schema: "input SetJwtInput {\n  jwt: String!\n}",
+                            scope: "global",
+                            template: "Sets the signed JWT representation of the credential",
+                        },
+                        {
+                            description: "Sets the credential status for revocation support (StatusList2021)",
+                            errors: [
+                                {
+                                    code: "INVALID_STATUS_PURPOSE",
+                                    description: "Status purpose must be either 'revocation' or 'suspension'",
+                                    id: "invalid-status-purpose-error",
+                                    name: "InvalidStatusPurposeError",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            id: "set-credential-status-op",
+                            name: "SET_CREDENTIAL_STATUS",
+                            reducer: '// Validate statusPurpose\nif (action.input.statusPurpose !== "revocation" && action.input.statusPurpose !== "suspension") {\n  throw new InvalidStatusPurposeError("Status purpose must be \'revocation\' or \'suspension\'");\n}\n\nstate.credentialStatus = {\n  id: action.input.statusId,\n  type: action.input.statusType,\n  statusPurpose: action.input.statusPurpose,\n  statusListIndex: action.input.statusListIndex,\n  statusListCredential: action.input.statusListCredential\n};',
+                            schema: "input SetCredentialStatusInput {\n  statusId: String!\n  statusType: String!\n  statusPurpose: String!\n  statusListIndex: String!\n  statusListCredential: String!\n}",
+                            scope: "global",
+                            template: "Sets the credential status for revocation support (StatusList2021)",
+                        },
                     ],
                 },
             ],
             state: {
                 global: {
                     examples: [],
-                    initialValue: '"{\\n  \\"jwt\\": null,\\n  \\"revoked\\": null,\\n  \\"issuer\\": null,\\n  \\"subject\\": null,\\n  \\"audience\\": null,\\n  \\"payload\\": null\\n}"',
-                    schema: 'type RenownCredentialState {\n  "Add your global state fields here"\n  jwt: String\n  revoked: Boolean\n  issuer: String\n  subject: String\n  audience: String\n  payload: String\n}',
+                    initialValue: '"{\\n  \\"context\\": [\\"https://www.w3.org/2018/credentials/v1\\"],\\n  \\"id\\": null,\\n  \\"type\\": [\\"VerifiableCredential\\"],\\n  \\"issuer\\": \\"\\",\\n  \\"issuanceDate\\": \\"\\",\\n  \\"credentialSubject\\": \\"{}\\",\\n  \\"expirationDate\\": null,\\n  \\"credentialStatus\\": null,\\n  \\"jwt\\": null,\\n  \\"revoked\\": false,\\n  \\"revokedAt\\": null,\\n  \\"revocationReason\\": null\\n}"',
+                    schema: 'type CredentialStatus {\n  id: String!\n  type: String!\n  statusPurpose: String!\n  statusListIndex: String!\n  statusListCredential: String!\n}\n\ntype RenownCredentialState {\n  "W3C VC Required Fields"\n  context: [String!]!\n  id: String\n  type: [String!]!\n  issuer: String!\n  issuanceDate: DateTime!\n  credentialSubject: String!\n  \n  "W3C VC Optional Fields"\n  expirationDate: DateTime\n  credentialStatus: CredentialStatus\n  \n  "JWT Representation"\n  jwt: String\n  \n  "Revocation tracking"\n  revoked: Boolean\n  revokedAt: DateTime\n  revocationReason: String\n}',
                 },
                 local: {
                     examples: [],

package/dist/document-models/renown-credential/gen/manager/actions.d.ts

@@ -1,5 +1,5 @@
 import { type Action } from "document-model";
-import type { InitInput, RevokeInput } from "../types.js";
+import type { InitInput, RevokeInput, UpdateCredentialSubjectInput, SetJwtInput, SetCredentialStatusInput } from "../types.js";
 export type InitAction = Action & {
     type: "INIT";
     input: InitInput;
@@ -8,4 +8,16 @@ export type RevokeAction = Action & {
     type: "REVOKE";
     input: RevokeInput;
 };
-export type RenownCredentialManagerAction = InitAction | RevokeAction;
+export type UpdateCredentialSubjectAction = Action & {
+    type: "UPDATE_CREDENTIAL_SUBJECT";
+    input: UpdateCredentialSubjectInput;
+};
+export type SetJwtAction = Action & {
+    type: "SET_JWT";
+    input: SetJwtInput;
+};
+export type SetCredentialStatusAction = Action & {
+    type: "SET_CREDENTIAL_STATUS";
+    input: SetCredentialStatusInput;
+};
+export type RenownCredentialManagerAction = InitAction | RevokeAction | UpdateCredentialSubjectAction | SetJwtAction | SetCredentialStatusAction;

package/dist/document-models/renown-credential/gen/manager/creators.d.ts

@@ -1,4 +1,7 @@
-import { type InitInput, type RevokeInput } from "../types.js";
-import { type InitAction, type RevokeAction } from "./actions.js";
+import { type InitInput, type RevokeInput, type UpdateCredentialSubjectInput, type SetJwtInput, type SetCredentialStatusInput } from "../types.js";
+import { type InitAction, type RevokeAction, type UpdateCredentialSubjectAction, type SetJwtAction, type SetCredentialStatusAction } from "./actions.js";
 export declare const init: (input: InitInput) => InitAction;
 export declare const revoke: (input: RevokeInput) => RevokeAction;
+export declare const updateCredentialSubject: (input: UpdateCredentialSubjectInput) => UpdateCredentialSubjectAction;
+export declare const setJwt: (input: SetJwtInput) => SetJwtAction;
+export declare const setCredentialStatus: (input: SetCredentialStatusInput) => SetCredentialStatusAction;

package/dist/document-models/renown-credential/gen/manager/creators.js

@@ -1,4 +1,7 @@
 import { createAction } from "document-model";
-import { z } from "../types.js";
+import { z, } from "../types.js";
 export const init = (input) => createAction("INIT", { ...input }, undefined, z.InitInputSchema, "global");
 export const revoke = (input) => createAction("REVOKE", { ...input }, undefined, z.RevokeInputSchema, "global");
+export const updateCredentialSubject = (input) => createAction("UPDATE_CREDENTIAL_SUBJECT", { ...input }, undefined, z.UpdateCredentialSubjectInputSchema, "global");
+export const setJwt = (input) => createAction("SET_JWT", { ...input }, undefined, z.SetJwtInputSchema, "global");
+export const setCredentialStatus = (input) => createAction("SET_CREDENTIAL_STATUS", { ...input }, undefined, z.SetCredentialStatusInputSchema, "global");

package/dist/document-models/renown-credential/gen/manager/error.d.ts

@@ -1 +1,45 @@
-export declare const errors: {};
+export type ErrorCode = "MissingContextError" | "MissingTypeError" | "InvalidClaimsError" | "AlreadyRevokedError" | "CredentialRevokedError" | "InvalidStatusPurposeError";
+export interface ReducerError {
+    errorCode: ErrorCode;
+}
+export declare class MissingContextError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare class MissingTypeError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare class InvalidClaimsError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare class AlreadyRevokedError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare class CredentialRevokedError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare class InvalidStatusPurposeError extends Error implements ReducerError {
+    errorCode: ErrorCode;
+    constructor(message?: string);
+}
+export declare const errors: {
+    Init: {
+        MissingContextError: typeof MissingContextError;
+        MissingTypeError: typeof MissingTypeError;
+        InvalidClaimsError: typeof InvalidClaimsError;
+    };
+    Revoke: {
+        AlreadyRevokedError: typeof AlreadyRevokedError;
+    };
+    UpdateCredentialSubject: {
+        InvalidClaimsError: typeof InvalidClaimsError;
+        CredentialRevokedError: typeof CredentialRevokedError;
+    };
+    SetCredentialStatus: {
+        InvalidStatusPurposeError: typeof InvalidStatusPurposeError;
+    };
+};

package/dist/document-models/renown-credential/gen/manager/error.js

@@ -1 +1,53 @@
-export const errors = {};
+export class MissingContextError extends Error {
+    errorCode = "MissingContextError";
+    constructor(message = "MissingContextError") {
+        super(message);
+    }
+}
+export class MissingTypeError extends Error {
+    errorCode = "MissingTypeError";
+    constructor(message = "MissingTypeError") {
+        super(message);
+    }
+}
+export class InvalidClaimsError extends Error {
+    errorCode = "InvalidClaimsError";
+    constructor(message = "InvalidClaimsError") {
+        super(message);
+    }
+}
+export class AlreadyRevokedError extends Error {
+    errorCode = "AlreadyRevokedError";
+    constructor(message = "AlreadyRevokedError") {
+        super(message);
+    }
+}
+export class CredentialRevokedError extends Error {
+    errorCode = "CredentialRevokedError";
+    constructor(message = "CredentialRevokedError") {
+        super(message);
+    }
+}
+export class InvalidStatusPurposeError extends Error {
+    errorCode = "InvalidStatusPurposeError";
+    constructor(message = "InvalidStatusPurposeError") {
+        super(message);
+    }
+}
+export const errors = {
+    Init: {
+        MissingContextError,
+        MissingTypeError,
+        InvalidClaimsError,
+    },
+    Revoke: {
+        AlreadyRevokedError,
+    },
+    UpdateCredentialSubject: {
+        InvalidClaimsError,
+        CredentialRevokedError,
+    },
+    SetCredentialStatus: {
+        InvalidStatusPurposeError,
+    },
+};

package/dist/document-models/renown-credential/gen/manager/object.d.ts

@@ -1,7 +1,10 @@
 import { BaseDocumentClass } from "document-model";
-import { RenownCredentialPHState } from "../ph-factories.js";
-import { type InitInput, type RevokeInput } from "../types.js";
+import { type RenownCredentialPHState } from "../ph-factories.js";
+import { type InitInput, type RevokeInput, type UpdateCredentialSubjectInput, type SetJwtInput, type SetCredentialStatusInput } from "../types.js";
 export default class RenownCredential_Manager extends BaseDocumentClass<RenownCredentialPHState> {
     init(input: InitInput): this;
     revoke(input: RevokeInput): this;
+    updateCredentialSubject(input: UpdateCredentialSubjectInput): this;
+    setJwt(input: SetJwtInput): this;
+    setCredentialStatus(input: SetCredentialStatusInput): this;
 }

package/dist/document-models/renown-credential/gen/manager/object.js

@@ -1,5 +1,5 @@
 import { BaseDocumentClass } from "document-model";
-import { init, revoke } from "./creators.js";
+import { init, revoke, updateCredentialSubject, setJwt, setCredentialStatus, } from "./creators.js";
 export default class RenownCredential_Manager extends BaseDocumentClass {
     init(input) {
         return this.dispatch(init(input));
@@ -7,4 +7,13 @@ export default class RenownCredential_Manager extends BaseDocumentClass {
     revoke(input) {
         return this.dispatch(revoke(input));
     }
+    updateCredentialSubject(input) {
+        return this.dispatch(updateCredentialSubject(input));
+    }
+    setJwt(input) {
+        return this.dispatch(setJwt(input));
+    }
+    setCredentialStatus(input) {
+        return this.dispatch(setCredentialStatus(input));
+    }
 }

package/dist/document-models/renown-credential/gen/manager/operations.d.ts

@@ -1,7 +1,10 @@
 import { type SignalDispatch } from "document-model";
-import { type InitAction, type RevokeAction } from "./actions.js";
+import { type InitAction, type RevokeAction, type UpdateCredentialSubjectAction, type SetJwtAction, type SetCredentialStatusAction } from "./actions.js";
 import { type RenownCredentialState } from "../types.js";
 export interface RenownCredentialManagerOperations {
     initOperation: (state: RenownCredentialState, action: InitAction, dispatch?: SignalDispatch) => void;
     revokeOperation: (state: RenownCredentialState, action: RevokeAction, dispatch?: SignalDispatch) => void;
+    updateCredentialSubjectOperation: (state: RenownCredentialState, action: UpdateCredentialSubjectAction, dispatch?: SignalDispatch) => void;
+    setJwtOperation: (state: RenownCredentialState, action: SetJwtAction, dispatch?: SignalDispatch) => void;
+    setCredentialStatusOperation: (state: RenownCredentialState, action: SetCredentialStatusAction, dispatch?: SignalDispatch) => void;
 }

package/dist/document-models/renown-credential/gen/object.d.ts

@@ -1,5 +1,5 @@
 import { BaseDocumentClass, type SignalDispatch } from "document-model";
-import { RenownCredentialPHState } from "./ph-factories.js";
+import { type RenownCredentialPHState } from "./ph-factories.js";
 import RenownCredential_Manager from "./manager/object.js";
 export * from "./manager/object.js";
 interface RenownCredential extends RenownCredential_Manager {

package/dist/document-models/renown-credential/gen/ph-factories.js

@@ -5,12 +5,18 @@ import { createBaseState, defaultBaseState, } from "document-model";
 import { createDocument } from "./utils.js";
 export function defaultGlobalState() {
     return {
+        context: ["https://www.w3.org/2018/credentials/v1"],
+        id: null,
+        type: ["VerifiableCredential"],
+        issuer: "",
+        issuanceDate: "",
+        credentialSubject: "{}",
+        expirationDate: null,
+        credentialStatus: null,
         jwt: null,
-        revoked: null,
-        issuer: null,
-        subject: null,
-        audience: null,
-        payload: null,
+        revoked: false,
+        revokedAt: null,
+        revocationReason: null,
     };
 }
 export function defaultLocalState() {

package/dist/document-models/renown-credential/gen/reducer.d.ts

@@ -1,4 +1,4 @@
 import { type StateReducer } from "document-model";
-import { RenownCredentialPHState } from "./ph-factories.js";
+import { type RenownCredentialPHState } from "./ph-factories.js";
 export declare const stateReducer: StateReducer<RenownCredentialPHState>;
 export declare const reducer: import("document-model").Reducer<RenownCredentialPHState>;

package/dist/document-models/renown-credential/gen/reducer.js

@@ -17,6 +17,18 @@ export const stateReducer = (state, action, dispatch) => {
             z.RevokeInputSchema().parse(action.input);
             ManagerReducer.revokeOperation(state[action.scope], action, dispatch);
             break;
+        case "UPDATE_CREDENTIAL_SUBJECT":
+            z.UpdateCredentialSubjectInputSchema().parse(action.input);
+            ManagerReducer.updateCredentialSubjectOperation(state[action.scope], action, dispatch);
+            break;
+        case "SET_JWT":
+            z.SetJwtInputSchema().parse(action.input);
+            ManagerReducer.setJwtOperation(state[action.scope], action, dispatch);
+            break;
+        case "SET_CREDENTIAL_STATUS":
+            z.SetCredentialStatusInputSchema().parse(action.input);
+            ManagerReducer.setCredentialStatusOperation(state[action.scope], action, dispatch);
+            break;
         default:
             return state;
     }

package/dist/document-models/renown-credential/gen/schema/types.d.ts

@@ -134,23 +134,54 @@ export type Scalars = {
         output: File;
     };
 };
+export type CredentialStatus = {
+    id: Scalars["String"]["output"];
+    statusListCredential: Scalars["String"]["output"];
+    statusListIndex: Scalars["String"]["output"];
+    statusPurpose: Scalars["String"]["output"];
+    type: Scalars["String"]["output"];
+};
 export type InitInput = {
-    audience?: InputMaybe<Scalars["String"]["input"]>;
-    issuer?: InputMaybe<Scalars["String"]["input"]>;
-    /** Add your inputs here */
-    jwt: Scalars["String"]["input"];
-    payload?: InputMaybe<Scalars["String"]["input"]>;
-    subject?: InputMaybe<Scalars["String"]["input"]>;
+    context?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    credentialSubject: Scalars["String"]["input"];
+    expirationDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+    id?: InputMaybe<Scalars["String"]["input"]>;
+    issuanceDate: Scalars["DateTime"]["input"];
+    issuer: Scalars["String"]["input"];
+    type?: InputMaybe<Array<Scalars["String"]["input"]>>;
 };
 export type RenownCredentialState = {
-    audience: Maybe<Scalars["String"]["output"]>;
-    issuer: Maybe<Scalars["String"]["output"]>;
-    /** Add your global state fields here */
+    /** W3C VC Required Fields */
+    context: Array<Scalars["String"]["output"]>;
+    credentialStatus: Maybe<CredentialStatus>;
+    credentialSubject: Scalars["String"]["output"];
+    /** W3C VC Optional Fields */
+    expirationDate: Maybe<Scalars["DateTime"]["output"]>;
+    id: Maybe<Scalars["String"]["output"]>;
+    issuanceDate: Scalars["DateTime"]["output"];
+    issuer: Scalars["String"]["output"];
+    /** JWT Representation */
     jwt: Maybe<Scalars["String"]["output"]>;
-    payload: Maybe<Scalars["String"]["output"]>;
+    revocationReason: Maybe<Scalars["String"]["output"]>;
+    /** Revocation tracking */
     revoked: Maybe<Scalars["Boolean"]["output"]>;
-    subject: Maybe<Scalars["String"]["output"]>;
+    revokedAt: Maybe<Scalars["DateTime"]["output"]>;
+    type: Array<Scalars["String"]["output"]>;
 };
 export type RevokeInput = {
-    jwt?: InputMaybe<Scalars["String"]["input"]>;
+    reason?: InputMaybe<Scalars["String"]["input"]>;
+    revokedAt: Scalars["DateTime"]["input"];
+};
+export type SetCredentialStatusInput = {
+    statusId: Scalars["String"]["input"];
+    statusListCredential: Scalars["String"]["input"];
+    statusListIndex: Scalars["String"]["input"];
+    statusPurpose: Scalars["String"]["input"];
+    statusType: Scalars["String"]["input"];
+};
+export type SetJwtInput = {
+    jwt: Scalars["String"]["input"];
+};
+export type UpdateCredentialSubjectInput = {
+    credentialSubject: Scalars["String"]["input"];
 };

package/dist/document-models/renown-credential/gen/schema/zod.d.ts

@@ -1,12 +1,16 @@
 import { z } from "zod";
-import type { InitInput, RenownCredentialState, RevokeInput } from "./types.js";
+import type { CredentialStatus, InitInput, RenownCredentialState, RevokeInput, SetCredentialStatusInput, SetJwtInput, UpdateCredentialSubjectInput } from "./types.js";
 type Properties<T> = Required<{
     [K in keyof T]: z.ZodType<T[K], any, T[K]>;
 }>;
 type definedNonNullAny = {};
 export declare const isDefinedNonNullAny: (v: any) => v is definedNonNullAny;
 export declare const definedNonNullAnySchema: z.ZodEffects<z.ZodAny, definedNonNullAny, any>;
+export declare function CredentialStatusSchema(): z.ZodObject<Properties<CredentialStatus>>;
 export declare function InitInputSchema(): z.ZodObject<Properties<InitInput>>;
 export declare function RenownCredentialStateSchema(): z.ZodObject<Properties<RenownCredentialState>>;
 export declare function RevokeInputSchema(): z.ZodObject<Properties<RevokeInput>>;
+export declare function SetCredentialStatusInputSchema(): z.ZodObject<Properties<SetCredentialStatusInput>>;
+export declare function SetJwtInputSchema(): z.ZodObject<Properties<SetJwtInput>>;
+export declare function UpdateCredentialSubjectInputSchema(): z.ZodObject<Properties<UpdateCredentialSubjectInput>>;
 export {};

package/dist/document-models/renown-credential/gen/schema/zod.js

@@ -3,28 +3,66 @@ export const isDefinedNonNullAny = (v) => v !== undefined && v !== null;
 export const definedNonNullAnySchema = z
     .any()
     .refine((v) => isDefinedNonNullAny(v));
+export function CredentialStatusSchema() {
+    return z.object({
+        __typename: z.literal("CredentialStatus").optional(),
+        id: z.string(),
+        statusListCredential: z.string(),
+        statusListIndex: z.string(),
+        statusPurpose: z.string(),
+        type: z.string(),
+    });
+}
 export function InitInputSchema() {
     return z.object({
-        audience: z.string().nullish(),
-        issuer: z.string().nullish(),
-        jwt: z.string(),
-        payload: z.string().nullish(),
-        subject: z.string().nullish(),
+        context: z.array(z.string()).nullish(),
+        credentialSubject: z.string(),
+        expirationDate: z.string().datetime().nullish(),
+        id: z.string().nullish(),
+        issuanceDate: z.string().datetime(),
+        issuer: z.string(),
+        type: z.array(z.string()).nullish(),
     });
 }
 export function RenownCredentialStateSchema() {
     return z.object({
         __typename: z.literal("RenownCredentialState").optional(),
-        audience: z.string().nullable(),
-        issuer: z.string().nullable(),
+        context: z.array(z.string()),
+        credentialStatus: CredentialStatusSchema().nullable(),
+        credentialSubject: z.string(),
+        expirationDate: z.string().datetime().nullable(),
+        id: z.string().nullable(),
+        issuanceDate: z.string().datetime(),
+        issuer: z.string(),
         jwt: z.string().nullable(),
-        payload: z.string().nullable(),
+        revocationReason: z.string().nullable(),
         revoked: z.boolean().nullable(),
-        subject: z.string().nullable(),
+        revokedAt: z.string().datetime().nullable(),
+        type: z.array(z.string()),
     });
 }
 export function RevokeInputSchema() {
     return z.object({
-        jwt: z.string().nullish(),
+        reason: z.string().nullish(),
+        revokedAt: z.string().datetime(),
+    });
+}
+export function SetCredentialStatusInputSchema() {
+    return z.object({
+        statusId: z.string(),
+        statusListCredential: z.string(),
+        statusListIndex: z.string(),
+        statusPurpose: z.string(),
+        statusType: z.string(),
+    });
+}
+export function SetJwtInputSchema() {
+    return z.object({
+        jwt: z.string(),
+    });
+}
+export function UpdateCredentialSubjectInputSchema() {
+    return z.object({
+        credentialSubject: z.string(),
     });
 }

package/dist/document-models/renown-credential/gen/utils.d.ts

@@ -1,6 +1,6 @@
 import { type CreateDocument, type CreateState, type LoadFromFile, type LoadFromInput } from "document-model";
 import { type RenownCredentialState, type RenownCredentialLocalState } from "./types.js";
-import { RenownCredentialPHState } from "./ph-factories.js";
+import { type RenownCredentialPHState } from "./ph-factories.js";
 export declare const initialGlobalState: RenownCredentialState;
 export declare const initialLocalState: RenownCredentialLocalState;
 export declare const createState: CreateState<RenownCredentialPHState>;

package/dist/document-models/renown-credential/gen/utils.js

@@ -1,12 +1,18 @@
 import { baseCreateDocument, baseSaveToFile, baseSaveToFileHandle, baseLoadFromFile, baseLoadFromInput, defaultBaseState, generateId, } from "document-model";
 import { reducer } from "./reducer.js";
 export const initialGlobalState = {
+    context: ["https://www.w3.org/2018/credentials/v1"],
+    id: null,
+    type: ["VerifiableCredential"],
+    issuer: "",
+    issuanceDate: "",
+    credentialSubject: "{}",
+    expirationDate: null,
+    credentialStatus: null,
     jwt: null,
-    revoked: null,
-    issuer: null,
-    subject: null,
-    audience: null,
-    payload: null,
+    revoked: false,
+    revokedAt: null,
+    revocationReason: null,
 };
 export const initialLocalState = {};
 export const createState = (state) => {

package/dist/document-models/renown-credential/index.d.ts

@@ -18,6 +18,9 @@ declare const utils: {
 declare const actions: {
     init: (input: import("./index.js").InitInput) => import("./gen/actions.js").InitAction;
     revoke: (input: import("./index.js").RevokeInput) => import("./gen/actions.js").RevokeAction;
+    updateCredentialSubject: (input: import("./index.js").UpdateCredentialSubjectInput) => import("./gen/actions.js").UpdateCredentialSubjectAction;
+    setJwt: (input: import("./index.js").SetJwtInput) => import("./gen/actions.js").SetJwtAction;
+    setCredentialStatus: (input: import("./index.js").SetCredentialStatusInput) => import("./gen/actions.js").SetCredentialStatusAction;
 };
 export declare const module: DocumentModelModule<RenownCredentialPHState>;
 export { reducer, actions, utils, documentModel };